kalo-cli 0.1.0

package/generators/constants.ts

@@ -0,0 +1,52 @@
+export const WAGTAIL_PAGE_TYPES = [
+    { name: 'Paire de Pages Standard (Index + Detail) : Pour une structure hiérarchique (ex: Liste de blog -> Article de blog).', value: 'page_pair' },
+    { name: 'Modèle Orderable : Pour gérer des listes ordonnées d\'éléments dans une page (ex: Carrousel, Galerie).', value: 'orderable' },
+    { name: 'Snippet Wagtail : Pour du contenu réutilisable hors arborescence (ex: Catégories, Auteurs, Publicités).', value: 'snippet' },
+    { name: 'Modèle Django Standard : Une table de base de données classique sans fonctionnalités CMS Wagtail.', value: 'model' },
+];
+
+export const MAIN_COMPONENT_TYPES = [
+    { name: 'Modifier une classe existante (AI Enhancer)', value: 'ai_enhancer' },
+    ...WAGTAIL_PAGE_TYPES,
+    { name: 'Block StreamField', value: 'block' },
+    { name: 'Vue Django (FBV/CBV)', value: 'view' },
+    { name: 'Formulaire Django', value: 'form' },
+    { name: 'Consumer Django Channel', value: 'channel' },
+    { name: 'Extension Admin Wagtail', value: 'admin_ext' },
+];
+
+export const VIEW_TYPES = [
+    { name: 'Vue basée sur une fonction (FBV) : Idéale pour une logique sur-mesure simple sans l\'abstraction des classes.', value: 'fbv' },
+    { name: 'TemplateView (CBV) : Affiche une page HTML statique ou avec des données contextuelles simples.', value: 'TemplateView' },
+    { name: 'ListView (CBV) : Génère une page listant plusieurs objets d\'un modèle (ex: catalogue, blog).', value: 'ListView' },
+    { name: 'DetailView (CBV) : Affiche les informations détaillées d\'un objet unique (ex: fiche produit, article).', value: 'DetailView' },
+    { name: 'CreateView (CBV) : Génère un formulaire pour ajouter une nouvelle entrée dans la base de données.', value: 'CreateView' },
+    { name: 'UpdateView (CBV) : Génère un formulaire pré-rempli pour modifier une entrée existante.', value: 'UpdateView' },
+    { name: 'DeleteView (CBV) : Affiche une page de confirmation avant la suppression définitive d\'un objet.', value: 'DeleteView' },
+];
+
+export const FORM_TYPES = [
+    { name: 'Formulaire Standard (forms.Form) : Pour traiter des données génériques (ex: recherche, contact).', value: 'form' },
+    { name: 'Formulaire de Modèle (forms.ModelForm) : Crée automatiquement des champs basés sur un modèle existant.', value: 'model_form' },
+];
+
+export const ADMIN_EXT_TYPES = [
+    { name: 'Vue d\'Administration (Page Personnalisée) : Ajoute une page complète dans le menu admin Wagtail.', value: 'view' },
+    { name: 'Composant Template (Panneau UI) : Crée un élément d\'interface réutilisable (Panel) pour les formulaires d\'édition.', value: 'component' },
+];
+
+export const CHANNEL_TYPES = [
+    { name: 'Consumer Websocket Asynchrone : Pour haute performance (chat, notifications) avec asyncio.', value: 'async' },
+    { name: 'Consumer Websocket Synchrone : Pour logique bloquante standard ou code hérité.', value: 'sync' },
+];
+
+export const AI_PROVIDER_TYPES = ['Qwen', 'Gemini'];
+
+export const AI_TEMP_TYPES = [
+    { name: 'Strict & Précis (0.1)', value: 0.1 },
+    { name: 'Équilibré (0.5)', value: 0.5 },
+    { name: 'Créatif (0.9)', value: 0.9 }
+];
+
+export const EXIT_VALUE = '__EXIT__';
+export const BACK_VALUE = '__BACK__';

package/generators/django-app/index.ts

@@ -0,0 +1,67 @@
+import { PlopGeneratorConfig } from 'plop';
+
+/**
+ * Generator configuration for creating a new Django Application.
+ * Sets up the standard directory structure, models, views, urls, and admin files.
+ *
+ * @type {PlopGeneratorConfig}
+ */
+export const djangoAppGenerator: PlopGeneratorConfig = {
+  description: 'Créer une nouvelle application Django avec la structure standard',
+  prompts: [
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Quel est le nom de l\'application Django ? (Cela créera un dossier avec models, views, urls pour une fonctionnalité)',
+      validate: (value) => {
+        if (/.+/.test(value)) {
+          return true;
+        }
+        return 'Le nom est requis';
+      },
+    },
+  ],
+  actions: [
+    {
+      type: 'add',
+      path: 'app/__init__.py',
+      templateFile: 'generators/django-app/templates/init.py.hbs',
+      skipIfExists: true,
+    },
+    {
+      type: 'add',
+      path: 'app/{{name}}/__init__.py',
+      templateFile: 'generators/django-app/templates/init.py.hbs',
+    },
+    {
+      type: 'add',
+      path: 'app/{{name}}/apps.py',
+      templateFile: 'generators/django-app/templates/apps.py.hbs',
+    },
+    {
+      type: 'add',
+      path: 'app/{{name}}/models/__init__.py',
+      templateFile: 'generators/django-app/templates/models_init.py.hbs',
+    },
+    {
+      type: 'add',
+      path: 'app/{{name}}/tests/__init__.py',
+      templateFile: 'generators/django-app/templates/init.py.hbs',
+    },
+    {
+      type: 'add',
+      path: 'app/{{name}}/views.py',
+      templateFile: 'generators/django-app/templates/views.py.hbs',
+    },
+    {
+      type: 'add',
+      path: 'app/{{name}}/urls.py',
+      templateFile: 'generators/django-app/templates/urls.py.hbs',
+    },
+    {
+      type: 'add',
+      path: 'app/{{name}}/admin.py',
+      templateFile: 'generators/django-app/templates/admin.py.hbs',
+    },
+  ],
+};

package/generators/django-app/templates/admin.py.hbs

@@ -0,0 +1,6 @@
+from django.contrib import admin
+from .models import *
+
+# Register your models here.
+# <!-- CLASS = {{pascalCase name}}Admin START AI_GENERATED_MODEL -->
+# <!-- CLASS = {{pascalCase name}}Admin END AI_GENERATED_MODEL -->

package/generators/django-app/templates/apps.py.hbs

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class {{pascalCase name}}Config(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'app.{{name}}'
+
+    # <!-- CLASS = {{pascalCase name}}Config START AI_GENERATED_CONFIG -->
+    # <!-- CLASS = {{pascalCase name}}Config END AI_GENERATED_CONFIG -->

package/generators/django-app/templates/models_init.py.hbs

@@ -0,0 +1,2 @@
+from .pages import *
+from .snippets import *

package/generators/django-app/templates/urls.py.hbs

@@ -0,0 +1,8 @@
+from django.urls import path
+from . import views
+
+urlpatterns = [
+# <!-- CLASS = {{pascalCase name}}Urls START AI_GENERATED_URL -->
+# <!-- CLASS = {{pascalCase name}}Urls END AI_GENERATED_URL -->
+    # path('', views.index, name='index'),
+]

package/generators/django-app/templates/views.py.hbs

@@ -0,0 +1,5 @@
+from django.shortcuts import render
+
+# Create your views here.
+# <!-- CLASS = {{pascalCase name}}Views START AI_GENERATED_VIEW -->
+# <!-- CLASS = {{pascalCase name}}Views END AI_GENERATED_VIEW -->

package/generators/django-channel/index.ts

@@ -0,0 +1,78 @@
+import { PlopGeneratorConfig } from 'plop';
+import { ensureSuffix, createAppendActions } from '../utils/plop-actions';
+import { CHANNEL_TYPES } from '../constants';
+import { searchChoices } from '../utils/search';
+
+/**
+ * Generator configuration for creating a Django Channel Consumer and Routing.
+ * Supports Async and Sync Websocket Consumers.
+ * Automatically configures routing and adds tests.
+ *
+ * @type {PlopGeneratorConfig}
+ */
+export const djangoChannelGenerator: PlopGeneratorConfig = {
+  description: 'Créer un Consumer Django Channel et son routing',
+  prompts: [
+    {
+      type: 'autocomplete',
+      name: 'type',
+      message: 'Quel type de consumer voulez-vous créer ?',
+      source: (answers, input) => searchChoices(input, CHANNEL_TYPES),
+    },
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Nom du Consumer (ex: ChatConsumer) :',
+      validate: (value) => {
+        return true;
+      },
+    },
+    {
+      type: 'input',
+      name: 'route',
+      message: 'Préfixe de la route URL (ex: chat -> ws/chat/room_name/) :',
+      default: 'chat',
+    },
+    {
+      type: 'input',
+      name: 'app',
+      message: 'Nom de l\'application cible',
+    },
+  ],
+  actions: (data) => {
+    const actions = [];
+    const appPath = `app/${data.app}`;
+    const isAsync = data.type === 'async';
+    data.isAsync = isAsync;
+
+    // Ensure suffix
+    data.name = ensureSuffix(data.name, 'Consumer');
+
+    // Ensure consumers.py exists and Append Consumer
+    actions.push(...createAppendActions({
+        path: `${appPath}/consumers.py`,
+        templateFile: 'generators/django-channel/templates/consumer.py.hbs',
+        dumbTemplate: 'import json\nfrom channels.generic.websocket import AsyncWebsocketConsumer, WebsocketConsumer\n\n',
+        dumbData: {},
+    }));
+
+    // Ensure routing.py exists
+    actions.push({
+      type: 'add',
+      path: `${appPath}/routing.py`,
+      templateFile: 'generators/django-channel/templates/routing.py.hbs',
+      skipIfExists: true,
+    });
+
+    // Append to websocket_urlpatterns in routing.py
+    // We look for the closing bracket of websocket_urlpatterns list
+    actions.push({
+      type: 'modify',
+      path: `${appPath}/routing.py`,
+      pattern: /(websocket_urlpatterns\s*=\s*\[)/,
+      template: '$1\n    re_path(r\'ws/{{ route }}/(?P<room_name>\\w+)/$\', consumers.{{ name }}.as_asgi()),',
+    });
+
+    return actions;
+  },
+};

package/generators/django-channel/templates/consumer.py.hbs

@@ -0,0 +1,47 @@
+import json
+from channels.generic.websocket import {{#if isAsync}}AsyncWebsocketConsumer{{else}}WebsocketConsumer{{/if}}
+
+class {{ name }}({{#if isAsync}}AsyncWebsocketConsumer{{else}}WebsocketConsumer{{/if}}):
+    # <!-- CLASS = {{ name }} START AI_GENERATED_CONSUMER -->
+    # <!-- CLASS = {{ name }} END AI_GENERATED_CONSUMER -->
+    {{#if isAsync}}async {{/if}}def connect(self):
+        self.room_name = self.scope['url_route']['kwargs']['room_name']
+        self.room_group_name = 'chat_%s' % self.room_name
+
+        # Join room group
+        {{#if isAsync}}await {{/if}}self.channel_layer.group_add(
+            self.room_group_name,
+            self.channel_name
+        )
+
+        {{#if isAsync}}await {{/if}}self.accept()
+
+    {{#if isAsync}}async {{/if}}def disconnect(self, close_code):
+        # Leave room group
+        {{#if isAsync}}await {{/if}}self.channel_layer.group_discard(
+            self.room_group_name,
+            self.channel_name
+        )
+
+    # Receive message from WebSocket
+    {{#if isAsync}}async {{/if}}def receive(self, text_data):
+        text_data_json = json.loads(text_data)
+        message = text_data_json['message']
+
+        # Send message to room group
+        {{#if isAsync}}await {{/if}}self.channel_layer.group_send(
+            self.room_group_name,
+            {
+                'type': 'chat_message',
+                'message': message
+            }
+        )
+
+    # Receive message from room group
+    {{#if isAsync}}async {{/if}}def chat_message(self, event):
+        message = event['message']
+
+        # Send message to WebSocket
+        {{#if isAsync}}await {{/if}}self.send(text_data=json.dumps({
+            'message': message
+        }))

package/generators/django-channel/templates/routing.py.hbs

@@ -0,0 +1,8 @@
+from django.urls import re_path
+from . import consumers
+
+websocket_urlpatterns = [
+# <!-- CLASS = {{pascalCase name}}Routing START AI_GENERATED_ROUTING -->
+# <!-- CLASS = {{pascalCase name}}Routing END AI_GENERATED_ROUTING -->
+    # re_path(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer.as_asgi()),
+]

package/generators/django-form/index.ts

@@ -0,0 +1,62 @@
+import { PlopGeneratorConfig } from 'plop';
+import { ensureSuffix, createAppendActions } from '../utils/plop-actions';
+import { FORM_TYPES } from '../constants';
+import { searchChoices } from '../utils/search';
+
+/**
+ * Generator configuration for creating a Django Form or ModelForm.
+ * Handles standard forms and model-bound forms.
+ *
+ * @type {PlopGeneratorConfig}
+ */
+export const djangoFormGenerator: PlopGeneratorConfig = {
+  description: 'Créer un Formulaire Django ou un ModelForm',
+  prompts: [
+    {
+      type: 'autocomplete',
+      name: 'type',
+      message: 'Quel type de formulaire voulez-vous créer ?',
+      source: (answers, input) => searchChoices(input, FORM_TYPES),
+    },
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Nom du Formulaire (ex: ContactForm, UserProfileForm) :',
+      validate: (value) => {
+        return true;
+      },
+    },
+    {
+      type: 'input',
+      name: 'model',
+      message: 'Nom du Modèle associé (ex: UserProfile) :',
+      when: (answers) => answers.type === 'model_form',
+    },
+    {
+      type: 'input',
+      name: 'app',
+      message: 'Nom de l\'application cible',
+    },
+  ],
+  actions: (data) => {
+    const actions = [];
+    const appPath = `app/${data.app}`;
+    const isModelForm = data.type === 'model_form';
+
+    // Ensure suffix
+    data.name = ensureSuffix(data.name, 'Form');
+
+    const templateFile = isModelForm 
+        ? 'generators/django-form/templates/model_form.py.hbs'
+        : 'generators/django-form/templates/form.py.hbs';
+
+    actions.push(...createAppendActions({
+        path: `${appPath}/forms.py`,
+        templateFile,
+        dumbTemplateFile: 'generators/django-form/templates/forms_file.py.hbs',
+        dumbData: data,
+    }));
+
+    return actions;
+  },
+};

package/generators/django-form/templates/form.py.hbs

@@ -0,0 +1,12 @@
+
+class {{ name }}(forms.Form):
+    # TODO: Define form fields here
+    # name = forms.CharField(max_length=100)
+    # message = forms.CharField(widget=forms.Textarea)
+
+    # <!-- CLASS = {{ name }} START AI_GENERATED_FORM -->
+    # <!-- CLASS = {{ name }} END AI_GENERATED_FORM -->
+    def clean(self):
+        cleaned_data = super().clean()
+        # TODO: Add custom validation logic
+        return cleaned_data

package/generators/django-form/templates/forms_file.py.hbs

@@ -0,0 +1,6 @@
+from django import forms
+
+# Create your forms here.
+# <!-- CLASS = {{pascalCase name}}Forms START AI_GENERATED_FORMS -->
+
+# <!-- CLASS = {{pascalCase name}}Forms END AI_GENERATED_FORMS -->

package/generators/django-form/templates/model_form.py.hbs

@@ -0,0 +1,18 @@
+
+{{#if model}}from .models import {{ model }}{{/if}}
+
+class {{ name }}(forms.ModelForm):
+    class Meta:
+
+{{#if model}}        model = {{ model }}{{/if}}
+{{#unless model}}        # model = YourModel{{/unless}}
+        fields = '__all__'  # TODO: Specify explicit fields ['field1', 'field2']
+        # widgets = {
+        #     'field_name': forms.TextInput(attrs={'class': 'form-control'}),
+        # }
+    # <!-- CLASS = {{ name }} START AI_GENERATED_MODEL_FORM -->
+    # <!-- CLASS = {{ name }} END AI_GENERATED_MODEL_FORM -->
+    def clean(self):
+        cleaned_data = super().clean()
+        # TODO: Add custom validation logic
+        return cleaned_data

package/generators/django-view/index.ts

@@ -0,0 +1,95 @@
+import { PlopGeneratorConfig } from 'plop';
+import { createAppendActions, ensureSuffix } from '../utils/plop-actions';
+import { VIEW_TYPES } from '../constants';
+import { searchChoices } from '../utils/search';
+
+/**
+ * Generator configuration for creating Django Views.
+ * Supports Function-Based Views (FBV) and Class-Based Views (CBV) including:
+ * - TemplateView, ListView, DetailView, CreateView, UpdateView, DeleteView.
+ * Handles automatic suffixing logic for naming conventions.
+ *
+ * @type {PlopGeneratorConfig}
+ */
+export const djangoViewGenerator: PlopGeneratorConfig = {
+  description: 'Créer une Vue Django (FBV ou CBV)',
+  prompts: [
+    {
+      type: 'autocomplete',
+      name: 'type',
+      message: 'Quel type de vue voulez-vous créer ?',
+      source: (answers, input) => searchChoices(input, VIEW_TYPES),
+    },
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Nom de la Vue (ex: UserProfile, ProductList) :',
+      validate: (value, answers) => {
+          return true;
+      }
+    },
+    {
+      type: 'input',
+      name: 'app',
+      message: 'Nom de l\'application cible',
+    },
+  ],
+  actions: (data) => {
+    const actions = [];
+    const appPath = `app/${data.app}`;
+    const isCBV = data.type !== 'fbv';
+
+    // Helper to ensure correct suffix for CBV
+    if (isCBV) {
+        let suffix = data.type; // e.g. ListView, DetailView
+        if (data.type === 'TemplateView') {
+            suffix = 'View';
+        }
+
+        if (!data.name.endsWith(suffix)) {
+            // Check if it ends with the "Type" part (e.g. "List" for "ListView")
+            const typePrefix = suffix.replace(/View$/, ''); // "List"
+            
+            if (typePrefix && data.name.endsWith(typePrefix)) {
+                // e.g. ProductList + ListView -> ProductListView
+                data.name = `${data.name}View`;
+            } else if (data.name.endsWith('View')) {
+                // e.g. ProductView + ListView -> ProductListView
+                data.name = data.name.replace(/View$/, suffix);
+            } else {
+                // e.g. Product + ListView -> ProductListView
+                data.name = `${data.name}${suffix}`;
+            }
+        }
+    } else {
+        // FBV
+        data.name = ensureSuffix(data.name, '_view');
+    }
+
+    // Helper for template name
+    data.templateName = data.name.replace(/View$/, '');
+
+    // Append to views.py
+    const templateFile = isCBV 
+        ? 'generators/django-view/templates/view_cbv.py.hbs' 
+        : 'generators/django-view/templates/view_fbv.py.hbs';
+
+    actions.push(...createAppendActions({
+        path: `${appPath}/views.py`,
+        templateFile,
+        dumbTemplate: 'from django.shortcuts import render\n\n',
+        dumbData: {},
+        appendData: isCBV ? { viewType: data.type } : undefined
+    }));
+
+    // Create Template
+    actions.push({
+        type: 'add',
+        path: `${appPath}/templates/${data.app}/{{snakeCase templateName}}.html`, // Clean filename
+        templateFile: 'generators/django-view/templates/view_template.html.hbs',
+        skipIfExists: true,
+    });
+
+    return actions;
+  },
+};

package/generators/django-view/templates/view_cbv.py.hbs

@@ -0,0 +1,11 @@
+
+class {{pascalCase name}}({{viewType}}):
+    """
+    Class-based view for {{name}}.
+    """
+    template_name = '{{app}}/{{snakeCase name}}.html'
+    
+    # <!-- CLASS = {{pascalCase name}} START AI_GENERATED_VIEW -->
+    # <!-- CLASS = {{pascalCase name}} END AI_GENERATED_VIEW -->
+    # context_object_name = '{{snakeCase name}}'
+    # model = MyModel

package/generators/django-view/templates/view_fbv.py.hbs

@@ -0,0 +1,7 @@
+
+def {{snakeCase name}}(request):
+    """
+    Function-based view for {{name}}.
+    """
+    context = {}
+    return render(request, '{{app}}/{{snakeCase name}}.html', context)

package/generators/django-view/templates/view_template.html.hbs

@@ -0,0 +1,8 @@
+{% extends "base.html" %}
+
+<!-- CLASS = {{pascalCase name}} START AI_GENERATED_VIEW_TEMPLATE -->
+{% block content %}
+  <h1>{{titleCase name}}</h1>
+  <p>Welcome to the {{name}} view.</p>
+{% endblock %}
+<!-- CLASS = {{pascalCase name}} END AI_GENERATED_VIEW_TEMPLATE -->

package/generators/docs/index.ts

@@ -0,0 +1,36 @@
+import { PlopGeneratorConfig } from 'plop';
+import { spawn } from 'child_process';
+
+export const docsGenerator: PlopGeneratorConfig = {
+    description: 'Ouvrir le serveur de documentation',
+    prompts: [],
+    actions: [
+        function runDocs() {
+            console.log('🚀 Démarrage du serveur de documentation...');
+            console.log('🌐 Accédez à http://localhost:3333');
+            
+            const isWindows = process.platform === 'win32';
+            const cmd = 'bun';
+            const args = ['run', '--port', '3333', 'docs-site/index.html'];
+            
+            const child = spawn(cmd, args, { 
+                stdio: 'inherit', 
+                shell: isWindows 
+            });
+
+            // Return a promise that resolves when the child process exits
+            return new Promise((resolve, reject) => {
+                 child.on('close', (code) => {
+                     if (code === 0) {
+                         resolve('Serveur arrêté');
+                     } else {
+                         reject(`Serveur arrêté avec le code ${code}`);
+                     }
+                 });
+                 child.on('error', (err) => {
+                     reject(err);
+                 });
+            });
+        }
+    ]
+};

package/generators/help/index.ts

@@ -0,0 +1,84 @@
+
+import { PlopGeneratorConfig } from 'plop';
+import keywordConfig from '../ai-enhancer/keywords.json';
+import { EXIT_VALUE } from '../constants';
+
+const getHelpItems = (input: string | undefined): any[] => {
+    const items: any[] = [];
+    
+    if (input) {
+        const inputLower = input.toLowerCase();
+        let lastMatchIndex = -1;
+        let matchedInstruction = null;
+
+        const keywords = Array.isArray(keywordConfig) ? keywordConfig : (keywordConfig as any).keywords || [];
+
+        for (const entry of keywords) {
+            if (entry.terms && Array.isArray(entry.terms)) {
+                for (const term of entry.terms) {
+                    const index = inputLower.lastIndexOf(term.toLowerCase());
+                    if (index !== -1 && index >= lastMatchIndex) {
+                        lastMatchIndex = index;
+                        matchedInstruction = entry.instruction;
+                    }
+                }
+            }
+        }
+
+        if (matchedInstruction) {
+            // Split instruction into lines of max 80 chars for better visibility
+            const words = matchedInstruction.split(' ');
+            let currentLine = '💡 ';
+            
+            for (const word of words) {
+                if ((currentLine + word).length > 80) {
+                    items.push({ name: currentLine, value: 'INFO', disabled: true });
+                    currentLine = '   ' + word + ' ';
+                } else {
+                    currentLine += word + ' ';
+                }
+            }
+            if (currentLine.trim()) {
+                items.push({ name: currentLine, value: 'INFO', disabled: true });
+            }
+            items.push({ name: '────────────────────────────────────────', value: 'SEP', disabled: true });
+        }
+    }
+    return items;
+};
+
+export const helpGenerator: PlopGeneratorConfig = {
+    description: 'Search for AI instructions and keywords',
+    prompts: [
+        {
+            type: 'autocomplete',
+            name: 'query',
+            message: 'Type a keyword to see associated instructions (e.g. "model", "field"):',
+            suggestOnly: true,
+            source: async (answers, input) => {
+                const choices: any[] = [];
+                
+                const helpItems = getHelpItems(input);
+                if (helpItems.length > 0) {
+                    choices.push(...helpItems);
+                }
+
+                if (!input) {
+                    choices.push({ name: 'Type to search...', value: 'INFO', disabled: true });
+                    choices.push({ name: 'Exit', value: EXIT_VALUE });
+                    return choices;
+                }
+                
+                choices.push({ name: 'Exit', value: EXIT_VALUE });
+                return choices;
+            },
+            validate: (value) => {
+                if (value === EXIT_VALUE || value?.toLowerCase() === 'exit') {
+                    process.exit(0);
+                }
+                return true;
+            }
+        }
+    ],
+    actions: []
+};