bob-core 0.8.7 → 0.9.1

package/README.md

@@ -1,5 +1,275 @@
-# BOB - Bash Operation Buddy
+# BOB Core - Bash Operation Buddy Core
 
 ## Introduction
 
-BOB (Bash Operation Buddy) est un le coeur pour crée facilement un CLI à votre sauce.
+BOB (Bash Operation Buddy) Core is a library that provides a set of functions to create your own CLI in TypeScript.
+
+## Usage
+
+```bash
+npm install bob-core
+```
+
+Initialize the CLI:
+
+```typescript
+import { CLI } from 'bob-core';
+
+const cli = new CLI();
+
+await cli.withCommands('./commands');
+
+cli.run('commandName', 'arg1', 'arg2', 'arg3');
+```
+
+Create a command in the `commands` folder:
+
+```typescript
+import { Command } from 'bob-core';
+
+export default class MyCommand extends Command {
+  public name = 'my-command {arg1} {--option1}';
+  public description = 'This is my command';
+  
+  /**
+   * Define the arguments and options help
+   *
+   * Optional
+   */
+  helpDefinition = {
+      arg1: 'This is the first argument',
+      '--option1': 'This is the first option'
+  }
+
+  /**
+   * Provide examples of how to use the command
+   *
+   * Optional
+   */
+  commandsExamples = [
+      {
+            command: 'my-command value1 --option1',
+            description: 'This is an example'
+      }
+  ]
+
+  public async handle() {
+    console.log('Hello World');
+    console.log('Arguments:', this.argument('arg1'));
+    console.log('Options:', this.option('option1'));
+  }
+}
+```
+
+## Cli Help
+
+The CLI provides a help command that displays all available commands and their descriptions.
+
+```bash
+node cli.js help
+```
+
+## Commands
+
+```bash
+Bob CLI x.x.x 💪
+
+Usage:
+  command [options] [arguments]
+
+Available commands:
+
+help         Show help
+test         test description
+sub:
+  sub        sub command description
+  sub:sub    sub:sub command description
+
+```
+
+## Command help
+
+You can also display the help of a specific command.
+
+```bash
+node cli.js test -h
+```
+
+```bash
+Description:
+  test description
+
+Usage:
+  test <user> [options]
+
+Arguments:
+  user                  user description
+  test                  test description [default: null]
+  test2                 [default: []] (variadic)
+
+Options:
+  --option, -o, -b      option description (boolean) [default: false]
+  --flag                flag description (string) [default: null]
+  --arr                 arr description (array) [default: null]
+  --flag2               flag2 description (string) [default: 2]
+  --help, -h            Display help for the given command. When no command is given display help for the list command (boolean)
+
+Examples:
+  Example description 1
+
+    node cli.js test yayo --option
+
+  Example description 2
+
+    node cli.js test anothervalue --flag=2
+```
+
+Depending on the command, the help will display the command signature, description, arguments, options and examples. 
+
+
+## Commands signature
+
+The command signature is a string that defines the command name, arguments and options.
+
+Example:    
+```typescript
+    signature = 'my-command {arg1} {arg2} {arg3} {--option1} {--option2}';
+```
+
+### Arguments
+
+All user supplied arguments and options are wrapped in curly braces. 
+In the following example, the command defines three **required** arguments `arg1`, `arg2` and `arg3`.
+
+```typescript
+    signature = 'my-command {arg1} {arg2} {arg3}';
+```
+
+You may want to make an argument optional by adding a `?` after the argument name or by providing a default value with `=`.
+
+```typescript
+    signature = 'my-command {arg1} {arg2?} {arg3=defaultValue}';
+
+    handle() {
+        this.argument('arg1'); // 'value' or throw an error if not provided
+        this.argument('arg2'); // 'value' or null if not provided
+        this.argument('arg3'); // 'value' or 'defaultValue' if not provided
+    }
+```
+
+You can also define a variadic argument by adding `*` after the argument name.
+Variadic arguments are stored in an array.
+
+```typescript
+    signature = 'my-command {arg1} {arg2*}';
+
+    handle() {
+        this.argument('arg1'); // 'value1'
+        this.argument('arg2'); // ['value2', 'value3']
+    }
+```
+
+Variadic arguments can also be optional.
+
+```typescript
+    signature = 'my-command {arg1} {arg2*?}';
+```
+
+### Options
+
+Options are defined by `{--optionName}`.
+
+```typescript
+    signature = 'my-command {--option1} {--option2} {--option3}';
+```
+
+By default options are boolean with a default value of `false`.
+You can also change the option type to string by adding `=` to the option definition.
+You can also provide a default value by adding `=value`.
+
+If the value is 'true' or 'false', the option will be converted to a boolean.
+
+```typescript
+    signature = 'my-command {--option1} {--option2=true} {--option3=} {--option4=defaultValue} {--option5=}';
+
+    handle() {
+        this.option('option1'); // by default `false` and can be set to `true` by the user 
+        this.option('option2'); // by default `true` and can be set to `false` by the user
+        this.option('option3'); // by default `null` and can be set to "value" by the user
+        this.option('option4'); // by default "defaultValue" and can be set to "value" by the user
+    }
+```
+
+You can also define a variadic option by adding `*` as option value. (e.g. `{--option2=*}`)
+Variadic options are stored in an array.
+
+```typescript
+    signature = 'my-command {--option1} {--option2=*}';
+
+    handle() {
+        this.option('option1'); // 'value1' 
+        this.option('option2'); // ['value2', 'value3'] // or [] if not provided
+    }
+```
+
+## Commands I/O
+
+### Arguments
+
+```typescript
+    this.argument('arg1');
+```
+
+You can also provide a default value if the argument is optional.
+
+```typescript
+    this.argument('arg1', 'defaultValue');
+```
+
+If you always need a boolean value, you can use the `argumentBoolean` method.
+
+```typescript
+    this.argumentBoolean('arg1');
+```
+
+If you always need a number value, you can use the `argumentNumber` method.
+
+```typescript
+    this.argumentNumber('arg1');
+```
+
+If you always need a array value, you can use the `argumentArray` method.
+
+```typescript
+    this.argumentArray('arg1');
+```
+
+### Options
+
+```typescript
+    this.option('option1');
+```
+
+You can also provide a default value if the option is optional.
+
+```typescript
+    this.option('option1', 'defaultValue');
+```
+
+If you always need a boolean value, you can use the `optionBoolean` method.
+
+```typescript
+    this.optionBoolean('option1');
+```
+
+If you always need a number value, you can use the `optionNumber` method.
+
+```typescript
+    this.optionNumber('option1');
+```
+
+If you always need a array value, you can use the `optionArray` method.
+
+```typescript
+    this.optionArray('option1'); 
+```

package/dist/Cli.d.ts

@@ -6,12 +6,16 @@ export declare class Cli<C> {
     readonly commandRegistry: CommandRegistry;
     private readonly exceptionHandler;
     private readonly ctx?;
+    private readonly helpCommand;
     get CommandRegistryClass(): typeof CommandRegistry;
     get HelpCommandClass(): typeof HelpCommand;
     get ExceptionHandlerClass(): typeof ExceptionHandler;
     constructor(ctx?: C);
     setCommandResolver(resolver: (path: string) => Promise<Command>): void;
-    loadCommandsPath(commandsPath: string): Promise<void>;
-    registerCommand(command: Command): void;
+    withCommands(...commands: Array<Command | {
+        new (): Command;
+    } | string>): Promise<void>;
     runCommand(command: string, ...args: any[]): Promise<number>;
+    runHelpCommand(): Promise<number>;
+    protected registerCommand(command: Command): void;
 }

package/dist/Cli.js

@@ -11,6 +11,7 @@ class Cli {
     commandRegistry;
     exceptionHandler;
     ctx;
+    helpCommand;
     get CommandRegistryClass() {
         return CommandRegistry_1.CommandRegistry;
     }
@@ -24,20 +25,36 @@ class Cli {
         this.ctx = ctx;
         this.commandRegistry = new this.CommandRegistryClass();
         this.exceptionHandler = new this.ExceptionHandlerClass();
-        this.registerCommand(new this.HelpCommandClass(this.commandRegistry));
+        this.helpCommand = new this.HelpCommandClass(this.commandRegistry);
+        this.registerCommand(this.helpCommand);
     }
     setCommandResolver(resolver) {
         this.commandRegistry.setCommandResolver(resolver);
     }
-    async loadCommandsPath(commandsPath) {
-        await this.commandRegistry.loadCommandsPath(commandsPath);
-    }
-    registerCommand(command) {
-        this.commandRegistry.registerCommand(command);
+    async withCommands(...commands) {
+        for (const command of commands) {
+            if (typeof command === 'string') {
+                await this.commandRegistry.loadCommandsPath(command);
+            }
+            else {
+                if (typeof command === 'function') {
+                    this.registerCommand(new command());
+                }
+                else {
+                    this.registerCommand(command);
+                }
+            }
+        }
     }
     async runCommand(command, ...args) {
         return await this.commandRegistry.runCommand(this.ctx, command, ...args)
             .catch(this.exceptionHandler.handle);
     }
+    async runHelpCommand() {
+        return await this.runCommand(this.helpCommand.command);
+    }
+    registerCommand(command) {
+        this.commandRegistry.registerCommand(command);
+    }
 }
 exports.Cli = Cli;

package/dist/Command.d.ts

@@ -1,5 +1,5 @@
 import { CommandHelper } from "./CommandHelper";
-import { CommandParser } from "./CommandParser";
+import { ArgSignature, CommandParser } from "./CommandParser";
 export type CommandExample = {
     description: string;
     command: string;
@@ -13,8 +13,10 @@ export declare abstract class Command<C = undefined> extends CommandHelper {
     };
     protected commandsExamples: CommandExample[];
     protected parser: CommandParser;
-    get command(): string;
     protected abstract handle(): Promise<void | number>;
+    private get CommandParserClass();
+    protected get defaultOptions(): ArgSignature[];
+    get command(): string;
     run(ctx: C, ...args: any[]): Promise<number>;
     protected setOption(name: string, value: any): void;
     protected setArgument(name: string, value: any): void;

package/dist/Command.js

@@ -1,13 +1,31 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
 const CommandHelper_1 = require("./CommandHelper");
 const CommandParser_1 = require("./CommandParser");
+const chalk_1 = __importDefault(require("chalk"));
 class Command extends CommandHelper_1.CommandHelper {
     ctx;
     helperDefinitions = {};
     commandsExamples = [];
     parser;
+    get CommandParserClass() {
+        return CommandParser_1.CommandParser;
+    }
+    get defaultOptions() {
+        return [
+            {
+                name: 'help',
+                optional: true,
+                type: 'boolean',
+                help: (0, chalk_1.default) `Display help for the given command. When no command is given display help for the {green list} command`,
+                alias: ['h']
+            }
+        ];
+    }
     get command() {
         if (this.parser) {
             return this.parser.command;
@@ -16,7 +34,7 @@ class Command extends CommandHelper_1.CommandHelper {
     }
     async run(ctx, ...args) {
         this.ctx = ctx;
-        this.parser = new CommandParser_1.CommandParser(this.signature, this.helperDefinitions, ...args);
+        this.parser = new this.CommandParserClass(this.signature, this.helperDefinitions, this.defaultOptions, ...args);
         if (args.includes('--help') || args.includes('-h')) {
             return this.help.call(this);
         }

package/dist/Command.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Command.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Command_1 = require("./Command");
+const MissingRequiredArgumentValue_1 = require("./errors/MissingRequiredArgumentValue");
+class MockCommand extends Command_1.Command {
+    signature = 'mockCommand {argument} {--option}';
+    description = 'This is a mock command for testing';
+    handle() {
+        const opts = this.option('option');
+        const arg = this.argument('argument');
+        if (opts) {
+            return Promise.resolve(11);
+        }
+        if (arg === 'value') {
+            return Promise.resolve(1);
+        }
+        else if (arg) {
+            return Promise.resolve(-1);
+        }
+        return Promise.resolve(0);
+    }
+}
+describe('Command', () => {
+    let command;
+    beforeEach(() => {
+        command = new MockCommand();
+    });
+    it('should have a command', () => {
+        expect(command.command).toBe('mockCommand');
+    });
+    it('should have a signature', () => {
+        expect(command.signature).toBe('mockCommand {argument} {--option}');
+    });
+    it('should have a description', () => {
+        expect(command.description).toBe('This is a mock command for testing');
+    });
+    it('should handle command with argument', async () => {
+        const result = await command.run(undefined, 'value');
+        expect(result).toBe(1);
+    });
+    it('should handle command with argument', async () => {
+        const result = await command.run(undefined, 'badValue');
+        expect(result).toBe(-1);
+    });
+    it('should throw error if argument is missing', async () => {
+        await expect(command.run(undefined)).rejects.toThrowError(MissingRequiredArgumentValue_1.MissingRequiredArgumentValue);
+    });
+    it('should handle command with option', async () => {
+        const result = await command.run(undefined, 'value', '--option');
+        expect(result).toBe(11);
+    });
+});

package/dist/CommandHelper.d.ts

@@ -1,6 +1,4 @@
 import { Command } from "./Command";
-import { ArgSignature } from "./CommandParser";
 export declare class CommandHelper {
-    get defaultOptions(): ArgSignature[];
     help(this: Command<any>): number;
 }

package/dist/CommandHelper.js

@@ -8,21 +8,10 @@ const chalk_1 = __importDefault(require("chalk"));
 const lodash_1 = require("lodash");
 const string_1 = require("./lib/string");
 class CommandHelper {
-    get defaultOptions() {
-        return [
-            {
-                name: 'help',
-                optional: true,
-                type: 'boolean',
-                help: (0, chalk_1.default) `Display help for the given command. When no command is given display help for the {green list} command`,
-                alias: ['h']
-            }
-        ];
-    }
     help() {
         const log = console.log;
-        const availableArguments = Object.values(this.parser.argumentsSignatures());
-        const availableOptions = [...Object.values(this.parser.optionsSignatures()), ...this.defaultOptions]
+        const availableArguments = Object.values(this.parser.getArgumentSignatures());
+        const availableOptions = Object.values(this.parser.getOptionSignatures())
             .map((signature) => ({
             ...signature,
             optionWithAlias: `--${signature.name}${signature.alias?.map(a => `, -${a}`).join('') ?? ''}`

package/dist/CommandParser.d.ts

@@ -13,24 +13,31 @@ export declare class CommandParser {
     protected readonly helperDefinitions: {
         [key: string]: string;
     };
+    protected readonly defaultOptions: ArgSignature[];
     command: string;
     private arguments;
     private options;
     private argumentsSignature;
-    private optionsSignature;
+    private optionSignatures;
+    private optionAliases;
     option(name: string): any;
     setOption(name: string, value: any): void;
+    optionHelp(name: string): string | undefined;
     argument(name: string): any;
     setArgument(name: string, value: any): void;
-    argumentsSignatures(): {
+    argumentHelp(name: string): string | undefined;
+    getArgumentSignatures(): {
         [argument: string]: ArgSignature;
     };
-    optionsSignatures(): {
+    getOptionSignatures(): {
         [option: string]: ArgSignature;
     };
     constructor(signature: string, helperDefinitions: {
         [key: string]: string;
-    }, ...args: any[]);
+    }, defaultOptions?: ArgSignature[], ...args: any[]);
+    private getParamValue;
+    private parseArguments;
+    private parseOptions;
     private parseSignature;
     private parseParamSignature;
     validate(): void;

package/dist/CommandParser.js

@@ -6,105 +6,154 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandParser = void 0;
 const minimist_1 = __importDefault(require("minimist"));
 const MissingRequiredArgumentValue_1 = require("./errors/MissingRequiredArgumentValue");
+const MissingSignatureOption_1 = require("./errors/MissingSignatureOption");
+const MissingSignatureArgument_1 = require("./errors/MissingSignatureArgument");
+const InvalidOption_1 = require("./errors/InvalidOption");
 class CommandParser {
     signature;
     helperDefinitions;
+    defaultOptions;
     command;
     arguments = {};
     options = {};
     argumentsSignature = {};
-    optionsSignature = {};
+    optionSignatures = {};
+    optionAliases = {};
     option(name) {
-        if (!this.optionsSignature[name]) {
-            throw new Error(`Option ${name} not found`);
-        }
-        const signature = this.optionsSignature[name];
-        if (signature.type === 'boolean') {
-            if (this.options[name] === 'true' || this.options[name] === '1') {
-                return true;
-            }
-            else if (this.options[name] === 'false' || this.options[name] === '0') {
-                return false;
-            }
-            return Boolean(this.options[name]);
-        }
-        if (signature.type === 'array') {
-            if (!this.options[name]) {
-                return [];
-            }
-            return Array.isArray(this.options[name]) ? this.options[name] : [this.options[name]];
+        if (!this.optionSignatures[name]) {
+            throw new MissingSignatureOption_1.MissingSignatureOption(name, Object.values(this.optionSignatures));
         }
         return this.options[name];
     }
     setOption(name, value) {
+        if (!this.optionSignatures[name]) {
+            throw new MissingSignatureOption_1.MissingSignatureOption(name, Object.values(this.optionSignatures));
+        }
         this.options[name] = value;
     }
+    optionHelp(name) {
+        const optionSignature = this.optionSignatures[name];
+        if (!optionSignature) {
+            throw new MissingSignatureOption_1.MissingSignatureOption(name, Object.values(this.optionSignatures));
+        }
+        return this.optionSignatures[name].help;
+    }
     argument(name) {
+        if (!this.argumentsSignature[name]) {
+            throw new MissingSignatureArgument_1.MissingSignatureArgument(name, Object.values(this.argumentsSignature));
+        }
         return this.arguments[name];
     }
     setArgument(name, value) {
+        if (!this.argumentsSignature[name]) {
+            throw new MissingSignatureArgument_1.MissingSignatureArgument(name, Object.values(this.argumentsSignature));
+        }
         this.arguments[name] = value;
     }
-    argumentsSignatures() {
+    argumentHelp(name) {
+        const argumentSignature = this.argumentsSignature[name];
+        if (!argumentSignature) {
+            throw new MissingSignatureArgument_1.MissingSignatureArgument(name, Object.values(this.argumentsSignature));
+        }
+        return this.argumentsSignature[name].help;
+    }
+    getArgumentSignatures() {
         return this.argumentsSignature;
     }
-    optionsSignatures() {
-        return this.optionsSignature;
+    getOptionSignatures() {
+        return this.optionSignatures;
     }
-    constructor(signature, helperDefinitions, ...args) {
+    constructor(signature, helperDefinitions, defaultOptions = [], ...args) {
         this.signature = signature;
         this.helperDefinitions = helperDefinitions;
-        const [command, ...params] = signature.split(/\{(.*?)\}/g).map(param => param.trim()).filter(Boolean);
+        this.defaultOptions = defaultOptions;
+        const [command, ...signatureParams] = signature.split(/\{(.*?)\}/g).map(param => param.trim()).filter(Boolean);
         const { _: paramValues, ...optionValues } = (0, minimist_1.default)(args);
+        if (defaultOptions.length) {
+            for (const option of defaultOptions) {
+                this.optionSignatures[option.name] = option;
+                this.options[option.name] = option.defaultValue;
+                if (option.alias) {
+                    for (const alias of option.alias) {
+                        this.optionAliases[alias] = option.name;
+                    }
+                }
+            }
+        }
         this.command = command;
-        this.parseSignature(params, optionValues, paramValues);
+        this.parseSignature(signatureParams);
+        this.parseArguments(paramValues);
+        this.parseOptions(optionValues);
+    }
+    getParamValue(value, signature) {
+        if (signature.type === 'boolean') {
+            if (value === 'true' || value === '1') {
+                return true;
+            }
+            else if (value === 'false' || value === '0') {
+                return false;
+            }
+            return Boolean(value);
+        }
+        if (signature.type === 'array') {
+            if (!value) {
+                return [];
+            }
+            return Array.isArray(value) ? value : [value];
+        }
+        return value ?? signature.defaultValue;
+    }
+    parseArguments(paramValues) {
+        for (const [argument, value] of Object.entries(this.arguments)) {
+            const argSignature = this.argumentsSignature[argument];
+            if (argSignature.variadic) {
+                this.arguments[argument] = paramValues;
+            }
+            else {
+                const paramValue = paramValues.shift();
+                this.arguments[argument] = this.getParamValue(paramValue, argSignature);
+            }
+        }
     }
-    parseSignature(params, optionValues, paramValues) {
+    parseOptions(optionValues) {
+        for (const [option, value] of Object.entries(optionValues)) {
+            const optionAlias = this.optionAliases[option];
+            const optionSignature = this.optionSignatures[option] ?? this.optionSignatures[optionAlias];
+            if (!optionSignature) {
+                throw new InvalidOption_1.InvalidOption(option, Object.values(this.optionSignatures));
+            }
+            this.options[option] = this.getParamValue(value, optionSignature);
+            for (const alias of optionSignature.alias ?? []) {
+                if (optionValues[alias]) {
+                    this.options[optionSignature.name] = optionValues[alias];
+                }
+            }
+        }
+    }
+    parseSignature(params) {
         for (const paramSignature of params) {
             const param = this.parseParamSignature(paramSignature);
             if (param.isOption) {
-                const optionValue = optionValues[param.name];
-                this.options[param.name] = optionValue ?? param.defaultValue ?? null;
-                this.optionsSignature[param.name] = param;
+                this.options[param.name] = param.defaultValue ?? null;
+                this.optionSignatures[param.name] = param;
                 for (const alias of param.alias ?? []) {
-                    if (optionValues[alias]) {
-                        this.options[param.name] = optionValues[alias];
-                        this.optionsSignature[param.name] = param;
-                    }
+                    this.optionAliases[alias] = param.name;
                 }
             }
             else {
-                if (param.variadic) {
-                    const paramValue = paramValues.splice(0, paramValues.length);
-                    this.arguments[param.name] = paramValue ?? [];
-                }
-                else {
-                    const paramValue = paramValues.shift();
-                    this.arguments[param.name] = paramValue ?? param.defaultValue ?? null;
-                }
+                this.arguments[param.name] = param.defaultValue ?? null;
                 this.argumentsSignature[param.name] = param;
             }
         }
     }
     parseParamSignature(argument) {
-        let cleanedArgs = argument;
-        let isOptional = false;
-        let isVariadic = false;
-        if (cleanedArgs.endsWith('?')) {
-            cleanedArgs = cleanedArgs.slice(0, -1);
-            isOptional = true;
-        }
-        if (cleanedArgs.endsWith('*')) {
-            cleanedArgs = cleanedArgs.slice(0, -1);
-            isVariadic = true;
-        }
         const arg = {
-            name: cleanedArgs,
-            optional: isOptional,
-            type: isVariadic ? 'array' : 'string',
+            name: argument,
+            optional: false,
+            type: 'string',
             help: undefined,
-            defaultValue: isVariadic ? [] : null,
-            variadic: isVariadic,
+            defaultValue: null,
+            variadic: false,
             isOption: false
         };
         if (arg.name.includes(':')) {
@@ -149,6 +198,16 @@ class CommandParser {
             arg.defaultValue = [];
             arg.type = 'array';
         }
+        if (arg.name.endsWith('?')) {
+            arg.optional = true;
+            arg.name = arg.name.slice(0, -1);
+        }
+        if (arg.name.endsWith('*')) {
+            arg.type = 'array';
+            arg.variadic = true;
+            arg.defaultValue = [];
+            arg.name = arg.name.slice(0, -1);
+        }
         arg.help = arg.help ?? this.helperDefinitions[arg.name] ?? this.helperDefinitions[`--${arg.name}`];
         return arg;
     }

package/dist/CommandParser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/CommandParser.test.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CommandParser_1 = require("./CommandParser");
+const MissingRequiredArgumentValue_1 = require("./errors/MissingRequiredArgumentValue");
+describe('CommandParser', () => {
+    let commandParser;
+    const parseCommand = (signature, args, helperDefinition = {}) => {
+        return new CommandParser_1.CommandParser(signature, helperDefinition, [], ...args);
+    };
+    it('should parse signature without arguments & options', () => {
+        commandParser = parseCommand('test', []);
+        expect(commandParser.command).toBe('test');
+    });
+    describe('Arguments', () => {
+        it('should parse signature with arguments', () => {
+            commandParser = parseCommand('test {arg1} {arg2}', ['value1', 'value2']);
+            expect(commandParser.argument('arg1')).toBe('value1');
+            expect(commandParser.argument('arg2')).toBe('value2');
+        });
+        it('should parse signature with optional arguments', () => {
+            commandParser = parseCommand('test {arg1?} {arg2?}', ['value1']);
+            expect(commandParser.argument('arg1')).toBe('value1');
+            expect(commandParser.argument('arg2')).toBeNull();
+        });
+        it('should parse signature with optional arguments with default value', () => {
+            commandParser = parseCommand('test {arg1?} {arg2=defaultValue1}', ['value1']);
+            expect(commandParser.argument('arg1')).toBe('value1');
+            expect(commandParser.argument('arg2')).toBe('defaultValue1');
+        });
+        it('should parse signature with variadic arguments', () => {
+            commandParser = parseCommand('test {arg1*}', ['value1', 'value2']);
+            expect(commandParser.argument('arg1')).toEqual(['value1', 'value2']);
+        });
+        it('should parse signature with optional variadic arguments', () => {
+            commandParser = parseCommand('test {arg1*?}', ['value1', 'value2']);
+            expect(commandParser.argument('arg1')).toEqual(['value1', 'value2']);
+        });
+        it('should parse signature with optional variadic arguments without value', () => {
+            commandParser = parseCommand('test {arg1*?}', []);
+            expect(commandParser.argument('arg1')).toEqual([]);
+        });
+        it('should set argument value', () => {
+            commandParser = parseCommand('test {arg1}', ['value1']);
+            commandParser.setArgument('arg1', 'newValue');
+            expect(commandParser.argument('arg1')).toBe('newValue');
+        });
+        it('should throw error when argument is missing with setArgument', () => {
+            commandParser = parseCommand('test {arg1}', []);
+            expect(() => commandParser.setArgument('arg2', 'newValue')).toThrowError(Error);
+        });
+        it('calling validate method should throw error when argument is missing', () => {
+            commandParser = parseCommand('test {arg1}', []);
+            expect(() => commandParser.validate()).toThrowError(MissingRequiredArgumentValue_1.MissingRequiredArgumentValue);
+        });
+        it('calling validate should throw with variadic argument is missing', () => {
+            commandParser = parseCommand('test {arg1*}', []);
+            expect(() => commandParser.validate()).toThrowError(MissingRequiredArgumentValue_1.MissingRequiredArgumentValue);
+        });
+    });
+    describe('Options', () => {
+        it('boolean option should be false when not provided', () => {
+            commandParser = parseCommand('test {--option}', []);
+            expect(commandParser.option('option')).toBeFalsy();
+        });
+        it('boolean option should be true when provided', () => {
+            commandParser = parseCommand('test {--option}', ['--option']);
+            expect(commandParser.option('option')).toBeTruthy();
+        });
+        it('boolean option should be true when provided with value', () => {
+            commandParser = parseCommand('test {--option}', ['--option=true']);
+            expect(commandParser.option('option')).toBeTruthy();
+        });
+        it('boolean option should be false when provided with value', () => {
+            commandParser = parseCommand('test {--option}', ['--option=false']);
+            expect(commandParser.option('option')).toBeFalsy();
+        });
+        it('string option should be null when not provided', () => {
+            commandParser = parseCommand('test {--option=}', []);
+            expect(commandParser.option('option')).toBeNull();
+        });
+        it('string option should be value when provided', () => {
+            commandParser = parseCommand('test {--option=}', ['--option=value']);
+            expect(commandParser.option('option')).toBe('value');
+        });
+        it('string option should take the default value when not provided', () => {
+            commandParser = parseCommand('test {--option=default}', []);
+            expect(commandParser.option('option')).toBe('default');
+        });
+        it('string option should take the provided value with default value', () => {
+            commandParser = parseCommand('test {--option=default}', ['--option=value']);
+            expect(commandParser.option('option')).toBe('value');
+        });
+        it('array option should be empty when not provided', () => {
+            commandParser = parseCommand('test {--option=*}', []);
+            expect(commandParser.option('option')).toEqual([]);
+        });
+        it('array option should be value when provided', () => {
+            commandParser = parseCommand('test {--option=*}', ['--option=value1', '--option=value2']);
+            expect(commandParser.option('option')).toEqual(['value1', 'value2']);
+        });
+    });
+    describe('Mixed', () => {
+        it('should parse signature with arguments and options', () => {
+            commandParser = parseCommand('test {arg1} {arg2} {--option}', ['value1', 'value2', '--option']);
+            expect(commandParser.argument('arg1')).toBe('value1');
+            expect(commandParser.argument('arg2')).toBe('value2');
+            expect(commandParser.option('option')).toBeTruthy();
+        });
+        it('should parse signature with optional arguments and options', () => {
+            commandParser = parseCommand('test {arg1?} {arg2?} {--option}', ['value1', '--option']);
+            expect(commandParser.argument('arg1')).toBe('value1');
+            expect(commandParser.argument('arg2')).toBeNull();
+            expect(commandParser.option('option')).toBeTruthy();
+        });
+    });
+    describe('Helper', () => {
+        it('should parse help signature', () => {
+            commandParser = parseCommand('test {arg1} {arg2:help 1} {--option : option help 2 }', ['value1', 'value2', '--option']);
+            expect(commandParser.argumentHelp('arg1')).toBeUndefined();
+            expect(commandParser.argumentHelp('arg2')).toBe('help 1');
+            expect(commandParser.optionHelp('option')).toBe('option help 2');
+        });
+        it('should define help with helperDefinition', () => {
+            commandParser = parseCommand('test {arg1} {arg2} {--option} {--option2}', ['value1', 'value2', '--option'], {
+                arg1: 'arg1 help',
+                arg2: 'arg2 help',
+                '--option': 'option help'
+            });
+            expect(commandParser.argumentHelp('arg1')).toBe('arg1 help');
+            expect(commandParser.argumentHelp('arg2')).toBe('arg2 help');
+            expect(commandParser.optionHelp('option')).toBe('option help');
+            expect(commandParser.optionHelp('option2')).toBeUndefined();
+        });
+        it('should define help with helperDefinition with default value', () => {
+            commandParser = parseCommand('test {arg1:arg1 help} {arg2} {--option=default}', ['value1', 'value2'], {
+                arg2: 'arg2 help',
+                '--option': 'option help'
+            });
+            expect(commandParser.argumentHelp('arg1')).toBe('arg1 help');
+            expect(commandParser.argumentHelp('arg2')).toBe('arg2 help');
+            expect(commandParser.optionHelp('option')).toBe('option help');
+        });
+    });
+});

package/dist/errors/InvalidOption.d.ts

@@ -0,0 +1,8 @@
+import { BobError } from "./BobError";
+import { ArgSignature } from "../CommandParser";
+export declare class InvalidOption extends BobError {
+    private option;
+    private optionsSignature;
+    constructor(option: string, optionsSignature: ArgSignature[]);
+    pretty(): void;
+}

package/dist/errors/InvalidOption.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidOption = void 0;
+const BobError_1 = require("./BobError");
+const chalk_1 = __importDefault(require("chalk"));
+class InvalidOption extends BobError_1.BobError {
+    option;
+    optionsSignature;
+    constructor(option, optionsSignature) {
+        super(`Invalid option ${option} in not recognized`);
+        this.option = option;
+        this.optionsSignature = optionsSignature;
+    }
+    pretty() {
+        const log = console.log;
+        if (this.optionsSignature.length > 0) {
+            log((0, chalk_1.default) `\n{yellow Available options}:`);
+            for (const option of this.optionsSignature) {
+                const type = option.type ? (0, chalk_1.default) `{white (${option.type})}` : '';
+                const nameWithAlias = `--${option.name}${option.alias?.map(a => `, -${a}`).join('') ?? ''}`;
+                const spaces = ' '.repeat(30 - nameWithAlias.length);
+                log((0, chalk_1.default) `  {green ${nameWithAlias}} ${spaces} ${option.help ?? '\b'} ${type}`);
+            }
+            log('');
+        }
+        log((0, chalk_1.default) `  {white.bgRed  ERROR } Option "{yellow ${this.option}}" is not recognized.`);
+    }
+}
+exports.InvalidOption = InvalidOption;

package/dist/errors/MissingSignatureArgument.d.ts

@@ -0,0 +1,8 @@
+import { BobError } from "./BobError";
+import { ArgSignature } from "../CommandParser";
+export declare class MissingSignatureArgument extends BobError {
+    private argument;
+    private argumentSignatures;
+    constructor(argument: string, argumentSignatures: ArgSignature[]);
+    pretty(): void;
+}

package/dist/errors/MissingSignatureArgument.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingSignatureArgument = void 0;
+const BobError_1 = require("./BobError");
+const chalk_1 = __importDefault(require("chalk"));
+class MissingSignatureArgument extends BobError_1.BobError {
+    argument;
+    argumentSignatures;
+    constructor(argument, argumentSignatures) {
+        super(`Missing ${argument} in the command signature`);
+        this.argument = argument;
+        this.argumentSignatures = argumentSignatures;
+    }
+    pretty() {
+        const log = console.log;
+        if (this.argumentSignatures.length) {
+            log((0, chalk_1.default) `\n{yellow Available arguments}:`);
+            for (const argument of this.argumentSignatures) {
+                const type = argument.type ? (0, chalk_1.default) `{white (${argument.type})}` : '';
+                const spaces = ' '.repeat(20 - argument.name.length);
+                log((0, chalk_1.default) `  {green ${argument.name}} ${spaces} ${argument.help ?? '\b'} ${type}`);
+            }
+            log('');
+        }
+        log((0, chalk_1.default) `  {white.bgRed  ERROR } Argument "{yellow ${this.argument}}" is missing in the signature.`);
+    }
+}
+exports.MissingSignatureArgument = MissingSignatureArgument;

package/dist/errors/MissingSignatureOption.d.ts

@@ -0,0 +1,8 @@
+import { BobError } from "./BobError";
+import { ArgSignature } from "../CommandParser";
+export declare class MissingSignatureOption extends BobError {
+    private option;
+    private optionsSignature;
+    constructor(option: string, optionsSignature: ArgSignature[]);
+    pretty(): void;
+}

package/dist/errors/MissingSignatureOption.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingSignatureOption = void 0;
+const BobError_1 = require("./BobError");
+const chalk_1 = __importDefault(require("chalk"));
+class MissingSignatureOption extends BobError_1.BobError {
+    option;
+    optionsSignature;
+    constructor(option, optionsSignature) {
+        super(`Missing ${option} in the command signature`);
+        this.option = option;
+        this.optionsSignature = optionsSignature;
+    }
+    pretty() {
+        const log = console.log;
+        if (this.optionsSignature.length) {
+            log((0, chalk_1.default) `{yellow Available options}:`);
+            for (const option of this.optionsSignature) {
+                const type = option.type ? (0, chalk_1.default) `{white (${option.type})}` : '';
+                const spaces = ' '.repeat(20 - option.name.length);
+                log((0, chalk_1.default) `  {green ${option.name}} ${spaces} ${option.help ?? '\b'} ${type}`);
+            }
+            log('');
+        }
+        log((0, chalk_1.default) `  {white.bgRed  ERROR } Option "{yellow ${this.option}}" is missing in the signature.`);
+    }
+}
+exports.MissingSignatureOption = MissingSignatureOption;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bob-core",
-  "version": "0.8.7",
+  "version": "0.9.1",
   "description": "BOB Core",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,18 +8,22 @@
     "/dist"
   ],
   "scripts": {
-    "start": "node -r @swc-node/register ./tests/main.ts",
+    "start": "node -r @swc-node/register debug/main.ts",
     "build": "tsc",
-    "prepare": "npm run build"
+    "prepare": "npm run build",
+    "test": "jest"
   },
   "author": "Léo Hubert",
   "license": "ISC",
   "devDependencies": {
     "@swc-node/register": "^1.9.2",
+    "@types/jest": "^29.5.12",
     "@types/lodash": "^4.17.5",
     "@types/minimist": "^1.2.5",
     "@types/node": "^20.14.5",
     "@types/string-similarity": "^4.0.2",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.5",
     "typescript": "^5.4.5"
   },
   "dependencies": {