bob-core 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# BOB - Bash Operation Buddy
+
+## Introduction
+
+BOB (Bash Operation Buddy) est un le coeur pour crée facilement un CLI à votre sauce.

package/dist/Cli.d.ts

@@ -0,0 +1,12 @@
+import { CommandRegistry } from "./CommandRegistry";
+import { Command } from "./Command";
+import HelpCommand from "./commands/HelpCommand";
+export declare class Cli {
+    readonly commandRegistry: CommandRegistry;
+    get CommandRegistryClass(): typeof CommandRegistry;
+    get HelpCommandClass(): typeof HelpCommand;
+    constructor();
+    loadCommandsPath(commandsPath: string): Promise<void>;
+    registerCommand(command: Command): void;
+    runCommand(command: string, ...args: any[]): Promise<void>;
+}

package/dist/Cli.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.Cli = void 0;
+const CommandRegistry_1 = require("./CommandRegistry");
+const HelpCommand_1 = __importDefault(require("./commands/HelpCommand"));
+class Cli {
+    commandRegistry;
+    get CommandRegistryClass() {
+        return CommandRegistry_1.CommandRegistry;
+    }
+    get HelpCommandClass() {
+        return HelpCommand_1.default;
+    }
+    constructor() {
+        this.commandRegistry = new this.CommandRegistryClass();
+        this.registerCommand(new this.HelpCommandClass(this.commandRegistry));
+    }
+    async loadCommandsPath(commandsPath) {
+        await this.commandRegistry.loadCommandsPath(commandsPath);
+    }
+    registerCommand(command) {
+        this.commandRegistry.registerCommand(command);
+    }
+    async runCommand(command, ...args) {
+        await this.commandRegistry.runCommand(command, ...args);
+    }
+}
+exports.Cli = Cli;

package/dist/Command.d.ts

@@ -0,0 +1,14 @@
+import { CommandHelper } from "./CommandHelper";
+export declare abstract class Command extends CommandHelper {
+    abstract signature: string;
+    abstract description: string;
+    private parser;
+    get command(): string;
+    protected abstract handle(): Promise<void | number>;
+    run(...args: any[]): Promise<number>;
+    protected option(key: string, defaultValue?: any): string | null;
+    protected argument(key: string, defaultValue?: any): string | null;
+    signatures(): {
+        [argument: string]: import("./Parser").ParamSignature;
+    };
+}

package/dist/Command.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+const CommandHelper_1 = require("./CommandHelper");
+const Parser_1 = require("./Parser");
+class Command extends CommandHelper_1.CommandHelper {
+    parser;
+    get command() {
+        return this.signature.split(' ')[0];
+    }
+    async run(...args) {
+        this.parser = new Parser_1.Parser(this.signature, ...args);
+        if (args.includes('--help') || args.includes('-h')) {
+            return this.help();
+        }
+        this.parser.validate();
+        return await this.handle() ?? 0;
+    }
+    option(key, defaultValue = null) {
+        return this.parser.option(key) ?? defaultValue;
+    }
+    argument(key, defaultValue) {
+        return this.parser.argument(key) ?? defaultValue;
+    }
+    signatures() {
+        return this.parser.signatures();
+    }
+}
+exports.Command = Command;

package/dist/CommandHelper.d.ts

@@ -0,0 +1,3 @@
+export declare class CommandHelper {
+    help(): number;
+}

package/dist/CommandHelper.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandHelper = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const lodash_1 = require("lodash");
+const string_1 = require("./lib/string");
+class CommandHelper {
+    help() {
+        const command = this;
+        const log = console.log;
+        const signatures = command.signatures();
+        const availableArguments = Object.entries(signatures).filter(([_, signature]) => !signature.isOption);
+        const availableOptions = Object.entries(signatures).filter(([_, signature]) => signature.isOption);
+        const requiredArguments = availableArguments.filter(([_, signature]) => !signature.optional);
+        log((0, chalk_1.default) `{yellow Description}:`);
+        log((0, chalk_1.default) `  ${command.description}\n`);
+        log((0, chalk_1.default) `{yellow Usage}:`);
+        log((0, chalk_1.default) `  ${command.command} ${requiredArguments.length > 0 ? requiredArguments.map(([arg]) => `<${arg}>`).join(' ') : '\b'} [options]`);
+        const maxOptionLength = (0, lodash_1.max)(availableOptions.map(([option]) => option.length)) ?? 0;
+        const maxArgumentLength = (0, lodash_1.max)(availableArguments.map(([arg]) => arg.length)) ?? 0;
+        const maxLength = maxArgumentLength > maxOptionLength ? maxArgumentLength : maxOptionLength;
+        if (availableArguments.length > 0) {
+            log((0, chalk_1.default) `{yellow Arguments}:`);
+            for (const [argument, signature] of availableArguments) {
+                const spaces = (0, string_1.generateSpace)(maxLength - argument.length);
+                log((0, chalk_1.default) `  {green ${argument}} ${spaces} ${signature.help ?? '\b'} ${signature.optional ? (0, chalk_1.default) `{gray (optional)}` : ''}`);
+            }
+            log((0, chalk_1.default) ``);
+        }
+        if (availableOptions.length > 0) {
+            log((0, chalk_1.default) `{yellow Options}:`);
+            for (const [option, signature] of availableOptions) {
+                const spaces = (0, string_1.generateSpace)(maxLength - option.length);
+                log((0, chalk_1.default) `  {green ${option}} ${spaces} ${signature.help ?? '\b'} `);
+            }
+        }
+        return -1;
+    }
+}
+exports.CommandHelper = CommandHelper;

package/dist/CommandRegistry.d.ts

@@ -0,0 +1,12 @@
+import { Command } from "./Command";
+export declare class CommandRegistry {
+    private readonly commands;
+    get commandSuffix(): string;
+    constructor();
+    getAvailableCommands(): string[];
+    getCommands(): Command[];
+    registerCommand(command: Command, force?: boolean): void;
+    loadCommandsPath(commandsPath: string): Promise<void>;
+    runCommand(command: string, ...args: any[]): Promise<number>;
+    private listCommandsFiles;
+}

package/dist/CommandRegistry.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandRegistry = void 0;
+const path_1 = __importDefault(require("path"));
+const fs = __importStar(require("node:fs"));
+class CommandRegistry {
+    commands = {};
+    get commandSuffix() {
+        return "Command.ts";
+    }
+    constructor() { }
+    getAvailableCommands() {
+        return Object.keys(this.commands);
+    }
+    getCommands() {
+        return Object.values(this.commands);
+    }
+    registerCommand(command, force = false) {
+        const commandName = command.signature.split(' ')[0];
+        if (!commandName) {
+            throw new Error('Command signature is invalid, it must have a command name.');
+        }
+        if (!force && this.commands[commandName]) {
+            throw new Error(`Command ${commandName} already registered.`);
+        }
+        this.commands[commandName] = command;
+    }
+    async loadCommandsPath(commandsPath) {
+        for await (const file of this.listCommandsFiles(commandsPath)) {
+            let CommandClass;
+            try {
+                CommandClass = (await require(file)).default;
+            }
+            catch (e) {
+                // Ignore files that are not commands
+                continue;
+            }
+            try {
+                const command = new CommandClass();
+                this.registerCommand(command);
+            }
+            catch (e) {
+                throw new Error(`Command ${file} failed to launch.`);
+            }
+        }
+    }
+    async runCommand(command, ...args) {
+        const commandToRun = this.commands[command];
+        if (!this.commands[command]) {
+            throw new Error(`Command ${command} not found.`);
+        }
+        return await commandToRun.run(...args);
+    }
+    async *listCommandsFiles(basePath) {
+        const dirEntry = fs.readdirSync(basePath, { withFileTypes: true });
+        for (const dirent of dirEntry) {
+            const direntPath = path_1.default.resolve(basePath, dirent.name);
+            if (dirent.isDirectory()) {
+                yield* this.listCommandsFiles(path_1.default.resolve(basePath, dirent.name));
+            }
+            else {
+                if (!direntPath.endsWith(this.commandSuffix)) {
+                    continue;
+                }
+                yield direntPath;
+            }
+        }
+    }
+}
+exports.CommandRegistry = CommandRegistry;

package/dist/Parser.d.ts

@@ -0,0 +1,23 @@
+export type ParamSignature = {
+    name: string;
+    optional: boolean;
+    alias?: string;
+    help?: string;
+    defaultValue?: string | boolean | null;
+    isOption: boolean;
+};
+export declare class Parser {
+    command: string;
+    private arguments;
+    private options;
+    private argumentsSignature;
+    option(name: string): any;
+    argument(name: string): any;
+    signatures(): {
+        [argument: string]: ParamSignature;
+    };
+    constructor(signature: string, ...args: any[]);
+    private parseSignature;
+    private parseParamSignature;
+    validate(): void;
+}

package/dist/Parser.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const minimist_1 = __importDefault(require("minimist"));
+class Parser {
+    command;
+    arguments = {};
+    options = {};
+    argumentsSignature = {};
+    option(name) {
+        return this.options[name];
+    }
+    argument(name) {
+        return this.arguments[name];
+    }
+    signatures() {
+        return this.argumentsSignature;
+    }
+    constructor(signature, ...args) {
+        const [command, ...params] = signature.split(/\{(.*?)\}/g).map(param => param.trim()).filter(Boolean);
+        const { _: paramValues, ...optionValues } = (0, minimist_1.default)(args);
+        this.command = command;
+        this.parseSignature(params, optionValues, paramValues);
+    }
+    parseSignature(params, optionValues, paramValues) {
+        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;
+            }
+            else {
+                const paramValue = paramValues.shift();
+                this.arguments[param.name] = paramValue ?? param.defaultValue ?? null;
+            }
+            this.argumentsSignature[param.name] = param;
+        }
+    }
+    parseParamSignature(argument) {
+        let cleanedArgs = argument;
+        let isOptional = false;
+        if (argument.endsWith('?')) {
+            cleanedArgs = cleanedArgs.slice(0, -1);
+            isOptional = true;
+        }
+        const arg = {
+            name: cleanedArgs,
+            optional: isOptional,
+            help: undefined,
+            defaultValue: null,
+            isOption: false
+        };
+        if (arg.name.includes(':')) {
+            const [name, help] = arg.name.split(':');
+            arg.name = name.trim();
+            arg.help = help.trim();
+        }
+        if (arg.name.includes('=')) {
+            const [name, defaultValue] = arg.name.split('=');
+            arg.name = name.trim();
+            arg.defaultValue = defaultValue.trim();
+            arg.optional = true;
+            if (!arg.defaultValue.length) {
+                arg.defaultValue = null;
+            }
+            else if (arg.defaultValue === 'true') {
+                arg.defaultValue = true;
+            }
+            else if (arg.defaultValue === 'false') {
+                arg.defaultValue = false;
+            }
+        }
+        else {
+            if (arg.name.startsWith('--')) {
+                arg.defaultValue = false;
+            }
+        }
+        if (arg.name.startsWith('--')) {
+            arg.isOption = true;
+            arg.name = arg.name.slice(2);
+        }
+        return arg;
+    }
+    validate() {
+        // validate arguments
+        for (const [argument, value] of Object.entries(this.arguments)) {
+            const signature = this.argumentsSignature[argument];
+            if (!value && !signature.optional) {
+                const argumentHelp = signature.help ?? 'no help available';
+                throw new Error(`Argument ${argument} is required. (help: ${argumentHelp})`);
+            }
+        }
+    }
+}
+exports.Parser = Parser;

package/dist/commands/HelpCommand.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "../Command";
+import { CommandRegistry } from "../CommandRegistry";
+export default class HelpCommand extends Command {
+    private commandRegistry;
+    signature: string;
+    description: string;
+    constructor(commandRegistry: CommandRegistry);
+    protected handle(): Promise<void>;
+}

package/dist/commands/HelpCommand.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Command_1 = require("../Command");
+const chalk_1 = __importDefault(require("chalk"));
+const lodash_1 = require("lodash");
+const string_1 = require("../lib/string");
+class HelpCommand extends Command_1.Command {
+    commandRegistry;
+    signature = 'help';
+    description = 'Show help';
+    constructor(commandRegistry) {
+        super();
+        this.commandRegistry = commandRegistry;
+    }
+    async handle() {
+        const commands = this.commandRegistry.getCommands();
+        const version = require('../../package.json').version;
+        console.log((0, chalk_1.default) `Bob CLI {green ${version}} 💪
+
+{yellow Usage}:
+  command [options] [arguments]
+
+{yellow Available commands}:
+`);
+        const maxCommandLength = (0, lodash_1.max)(commands.map(command => command.command.length)) ?? 0;
+        const commandByGroups = {};
+        for (const command of commands) {
+            const commandGroup = command.command.split(':')[0];
+            if (!commandByGroups[commandGroup]) {
+                commandByGroups[commandGroup] = [];
+            }
+            commandByGroups[commandGroup].push(command);
+        }
+        const sortedCommandsByGroups = (0, lodash_1.orderBy)((0, lodash_1.orderBy)(Object.entries(commandByGroups), [([group]) => group.toLowerCase()], ['asc']), [([_, commands]) => commands.length], ['asc']);
+        for (const [group, groupCommands] of sortedCommandsByGroups) {
+            const isGrouped = groupCommands.length > 1;
+            if (isGrouped) {
+                console.log((0, chalk_1.default) `{yellow ${group}}:`);
+            }
+            const sortedGroupCommands = (0, lodash_1.orderBy)(groupCommands, [command => command.command.toLowerCase()], ['asc']);
+            for (const command of sortedGroupCommands) {
+                let spaces = (0, string_1.generateSpace)(maxCommandLength - command.command.length);
+                if (isGrouped) {
+                    spaces = spaces.slice(2);
+                }
+                console.log((0, chalk_1.default) `${isGrouped ? '  ' : ''}{green ${command.command}} ${spaces} ${command.description}`);
+            }
+        }
+    }
+}
+exports.default = HelpCommand;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Command';
+export * from './Cli';

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Command"), exports);
+__exportStar(require("./Cli"), exports);

package/dist/lib/string.d.ts

@@ -0,0 +1 @@
+export declare function generateSpace(nb: number): string;

package/dist/lib/string.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSpace = void 0;
+function generateSpace(nb) {
+    return new Array(nb + 5).join(' ');
+}
+exports.generateSpace = generateSpace;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "bob-core",
+  "version": "0.1.0",
+  "description": "BOB Core",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
+  "scripts": {
+    "start": "ts-node ./tests/main.ts",
+    "build": "tsc"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/lodash": "^4.17.5",
+    "@types/minimist": "^1.2.5",
+    "@types/node": "^20.14.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "lodash": "^4.17.21",
+    "minimist": "^1.2.8"
+  }
+}