BREAKING CHANGE: Total refactor with cli colors, extensible plugins and npm package.

Author: BlorisL

.env

@@ -1,2 +1,3 @@
-LANGUAGE=en
-DEBUG_LOG=false
+MENU_LANGUAGE=en
+DEBUG_LOG=false
+DIR_PLUGINS=./src/plugins

.github/workflows/release.yml

@@ -0,0 +1,48 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write # Permette push di tag e modifiche al repository
+  issues: write   # Permette di creare/modificare issue (per note di rilascio)
+  pull-requests: write # Opzionale, per gestire PR
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npx semantic-release
+
+      - name: Sync dev branch with main
+        if: success()
+        run: |
+          git fetch origin dev:dev || git checkout -b dev
+          git checkout dev
+          git pull origin dev || true
+          git merge main --ff-only || (git merge main && git push origin dev)
+          git push origin dev

.npmignore

@@ -0,0 +1,7 @@
+src/
+*.ts
+tests/
+node_modules/
+.gitignore
+.github/
+tsconfig.json

.releaserc

@@ -0,0 +1,11 @@
+{
+  "branches": ["main"],
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    "@semantic-release/changelog",
+    "@semantic-release/npm",
+    "@semantic-release/git",
+    "@semantic-release/github"
+  ]
+}

README.md

@@ -1,91 +1,232 @@
-# Modular CLI Menu System
+# Modular CLI Menu
 
-A flexible and extensible command-line interface menu system built with TypeScript, designed to be easily extendable through plugins.
+A TypeScript library for creating modular and interactive CLI menus with plugin support and internationalization.
 
-## Overview
+## Installation
 
-This project provides a modular framework for creating interactive CLI menus with support for:
+```bash
+npm install modular-cli-menu
+```
 
-- Multi-language support (currently English and Italian)
-- Plugin-based architecture for easy extension
-- Hierarchical menu navigation
-- Environment configuration
+## Key Features
 
-## Features
+- 🔌 Modular plugin system
+- 🌍 Multi-language support (i18n)
+- 🎨 Customizable menu colors
+- 🔄 Hierarchical menu navigation
+- ⌨️ Interactive input with different question types
+- 📦 Easily extensible
 
-- **Plugin System**: Extend functionality by adding new plugins with their own menus and actions
-- **Internationalization**: Full multi-language support with automatic translation loading
-- **Configurable Navigation**: Define how users navigate through menus after actions complete
-- **Dynamic Menu Loading**: Menus and actions are loaded dynamically at runtime
+## Basic Usage
 
-## Project Structure
+```typescript
+import { print, write } from 'modular-cli-menu';
 
+// Start the main menu
+print();
+
+// Use write for custom messages
+write('Hello World', 'green');
 ```
-.
-├── languages/               # Global translations
-│   ├── en.json             # English translations
-│   └── it.json             # Italian translations
-├── plugins/                # Plugin modules
-│   ├── settings/           # Settings plugin
-│   └── show-info/          # Information display plugin
-├── src/
-│   ├── actions/            # Core actions
-│   ├── classes/            # Core classes (Menu, MenuItem, etc.)
-│   ├── interfaces/         # TypeScript interfaces
-│   ├── utils/              # Utility functions
-│   └── index.ts            # Application entry point
-├── .env                    # Default environment configuration
-└── .env.local              # Local environment overrides
+
+### Using print and write Methods
+
+The library provides two main methods for output:
+
+- `print()`: Initializes and displays the menu interface
+- `write(message: string, color?: ColorName)`: Prints custom messages with optional styling
+  ```typescript
+  write('Success!', 'green');
+  write('Error!', 'red');
+  ```
+
+## Creating and Registering Plugins
+
+To create a new plugin, define an object implementing the `PluginType` interface:
+
+```typescript
+import { addPlugin } from 'modular-cli-menu';
+import type { PluginType, ActionType } from 'modular-cli-menu';
+
+const myPlugin: PluginType = {
+    menu: {
+        name: 'myplugin',           // Unique menu name
+        parent: 'main',             // Parent menu (optional)
+        color: 'blue',              // Menu color (optional)
+        choices: [                  // Array of available actions
+            'menu.myplugin.action1',
+            'menu.myplugin.action2',
+            'menu.action.back'
+        ]
+    },
+    actions: {
+        'menu.myplugin.action1': {
+            type: 'function',
+            name: 'menu.myplugin.action1',
+            color: 'green',
+            options: {
+                message: {
+                    text: 'Action 1 executed!',
+                    color: 'green'
+                }
+            }
+        }
+    },
+    languages: {
+        en: {
+            'menu.myplugin.question': 'My Plugin',
+            'menu.myplugin.action1': 'Execute Action 1',
+            'menu.myplugin.action2': 'Execute Action 2'
+        }
+    }
+};
 ```
 
-## How It Works
+In the main file remember to register the plugin
+```typescript
+import module1 from './plugins/myPlugin/index.ts';
+import { addPlugin, print } from 'modular-cli-menu';
 
-The application loads menus from configuration files (`menu.json`) found in both the core application and plugins. Each menu item can either lead to a submenu or execute an action.
+addPlugin(myPlugin);
 
-### Environment Variables
+print();
+```
 
-- `LANGUAGE`: Sets the default language (e.g., "en" or "it")
-- `DEBUG_LOG`: When set to "true", enables detailed logging
+## Navigation and Control Methods
 
-## Adding a New Plugin
+The library provides several methods for menu navigation and control:
 
-To add a new plugin:
+### actionExit
 
-1. Create a new directory under `/plugins/`
-2. Add a `menu.json` file defining menu structure
-3. Add language files under `/languages/` directory
-4. Implement actions as TypeScript files in an `actions/` subdirectory
+`menu.action.exit` can be used to terminate the application. 
+Add it to your menu's choices:
 
-## Getting Started
+```typescript
+import { actionExit } from 'modular-cli-menu';
 
-### Prerequisites
+const myPlugin: PluginType = {
+    menu: {
+        name: 'myplugin',
+        choices: [
+            'menu.myplugin.action1',
+            'menu.action.exit' // This will add an exit option to your menu
+        ]
+    },
+    // ... rest of the plugin configuration
+};
+```
 
-- Node.js (v14 or higher)
-- npm or yarn
+### actionGoBack
 
-### Installation
+`menu.action.back` can be used to navigate to the previous menu. 
+Add it to your menu's choices:
 
-```bash
-# Clone the repository
-git clone https://github.com/BlorisL/modular-cli-menu.git
+```typescript
+import { actionGoBack } from 'modular-cli-menu';
 
-# Navigate to project directory
-cd modular-cli-menu
+const myPlugin: PluginType = {
+    menu: {
+        name: 'myplugin',
+        choices: [
+            'menu.myplugin.action1',
+            'menu.action.back' // This will add a "back" option to your menu
+        ]
+    },
+    // ... rest of the plugin configuration
+};
+```
 
-# Install dependencies
-npm install
+### waitForKeyPress
 
-# Start the application
-npm start
+Use `waitForKeyPress()` to pause execution until the user presses a key:
+
+```typescript
+import { waitForKeyPress } from 'modular-cli-menu';
+
+const myAction: ActionType = {
+    type: 'function',
+    options: {
+        callback: async (parent?:) => {
+            await waitForKeyPress();
+            // Continue with the next actions
+        }
+    }
+};
 ```
 
-## Configuration
+## Action Types
+
+The library supports different types of actions:
+
+1. **function**: Executes a callback function
+2. **input**: Requests user input
+3. **checkbox**: Allows multiple selections
+4. **goto**: Navigates to another menu
+
+### Function Action Example
+
+```typescript
+{
+    type: 'function',
+    name: 'myAction',
+    color: 'green',
+    options: {
+        message: {
+            text: 'Action executed!',
+            color: 'green'
+        },
+        callback: async () => {
+            // Your logic here
+        }
+    }
+}
+```
 
-You can customize the application by creating a `.env.local` file based on the `.env.example` template.
+### Input Action Example
+
+```typescript
+{
+    type: 'input',
+    name: 'inputAction',
+    color: 'yellow',
+    options: {
+        message: {
+            text: 'Enter a value:',
+            color: 'yellow'
+        },
+        callback: async (value, parent) => {
+            console.log(`Entered value: ${value}`);
+        }
+    }
+}
+```
 
-## License
+### Checkbox Action Example
+
+```typescript
+{
+    type: 'checkbox',
+    name: 'checkboxAction',
+    options: {
+        choices: ['Option 1', 'Option 2', 'Option 3'],
+        callback: async (selected) => {
+            console.log('Selected options:', selected);
+        }
+    }
+}
+```
+
+### Goto Action Example
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+```typescript
+{
+    type: 'goto',
+    name: 'gotoAction',
+    options: {
+        menu: 'targetMenuName'
+    }
+}
+```
 
 ## Support me