express-genix 4.5.2 → 4.6.1

package/templates/core/docker-compose.yml.ejs

@@ -1,11 +1,24 @@
 # templates/core/docker-compose.yml.ejs
 version: '3.8'
 
-services:
+services:<% if (typeof hasNginx !== 'undefined' && hasNginx) { %>
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+    volumes:
+      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+    depends_on:
+      - app
+    restart: unless-stopped
+    networks:
+      - app-network
+<% } %>
   app:
     build: .
-    ports:
-      - "3000:3000"
+    ports:<% if (typeof hasNginx !== 'undefined' && hasNginx) { %>
+      - "3000" # Exposed to Nginx, not host directly<% } else { %>
+      - "3000:3000"<% } %>
     environment:
       - NODE_ENV=production
     env_file:

package/templates/core/env.ejs

@@ -9,10 +9,8 @@ JWT_REFRESH_SECRET=<%= jwtRefreshSecret %>
 JWT_EXPIRE=15m
 JWT_REFRESH_EXPIRE=7d
 <% } %><% if (hasRedis) { %>
-# Redis (token blacklist store)
+# Redis
 REDIS_URL=redis://localhost:6379
-<% } %><% if (hasBackgroundJobs && !hasRedis) { %>
-# Redis (required for BullMQ)
 REDIS_HOST=localhost
 REDIS_PORT=6379
 <% } %><% if (hasEmail) { %>

package/templates/core/env.example.ejs

@@ -9,10 +9,8 @@ JWT_REFRESH_SECRET=CHANGE_ME_generate_a_64_char_hex_secret
 JWT_EXPIRE=15m
 JWT_REFRESH_EXPIRE=7d
 <% } %><% if (hasRedis) { %>
-# Redis (token blacklist store)
+# Redis
 REDIS_URL=redis://localhost:6379
-<% } %><% if (hasBackgroundJobs && !hasRedis) { %>
-# Redis (required for BullMQ)
 REDIS_HOST=localhost
 REDIS_PORT=6379
 <% } %><% if (hasEmail) { %>

package/templates/core/server.js.ejs

@@ -1,7 +1,5 @@
 require('dotenv').config();
 
-const cluster = require('cluster');
-const os = require('os');
 <% if (hasWebsocket) { %>const http = require('http');<% } %>
 const app = require('./app');<% if (hasDatabase) { %>
 const db = require('./config/database');<% } %><% if (hasRedis) { %>
@@ -12,22 +10,9 @@ const { createLogger } = require('./utils/logger');
 
 const logger = createLogger('Server');
 const port = process.env.PORT || 3000;
-const isPrimary = cluster.isPrimary ?? cluster.isMaster;
 
 const startServer = async () => {
-  if (process.env.NODE_ENV === 'production' && isPrimary) {
-    const numCPUs = os.cpus().length;
-    logger.info(`Master ${process.pid} is running, forking ${numCPUs} workers`);
-
-    for (let i = 0; i < numCPUs; i++) {
-      cluster.fork();
-    }
-
-    cluster.on('exit', (worker, code, signal) => {
-      logger.warn(`Worker ${worker.process.pid} died (code: ${code}, signal: ${signal}). Restarting...`);
-      cluster.fork();
-    });
-  } else {<% if (hasDatabase) { %>
+  try {<% if (hasDatabase) { %>
     await db.connect();<% } %><% if (hasRedis) { %>
     await connectRedis();<% } %><% if (hasGraphQL) { %>
     await app.initGraphQL();<% } %><% if (hasBackgroundJobs) { %>
@@ -38,7 +23,7 @@ const startServer = async () => {
     app.set('io', io);
 
     const server = httpServer.listen(port, () => {<% } else { %>    const server = app.listen(port, () => {<% } %>
-      logger.info(`Worker ${process.pid} running on http://localhost:${port}`);
+      logger.info(`Server running on http://localhost:${port}`);
       logger.info(`Environment: ${process.env.NODE_ENV || 'development'}`);
     });
 
@@ -59,10 +44,10 @@ const startServer = async () => {
 
     process.on('SIGTERM', () => shutdown('SIGTERM'));
     process.on('SIGINT', () => shutdown('SIGINT'));
+  } catch (err) {
+    logger.error('Failed to start server', { error: err.message });
+    process.exit(1);
   }
 };
 
-startServer().catch((err) => {
-  logger.error('Failed to start server', { error: err.message });
-  process.exit(1);
-});
+startServer();

package/templates/infra/Makefile.ejs

@@ -0,0 +1,30 @@
+.PHONY: build up down logs test lint clean
+
+# Build the Docker image
+build:
+	docker-compose build
+
+# Start the application in detached mode
+up:
+	docker-compose up -d
+
+# Stop the application
+down:
+	docker-compose down
+
+# View logs
+logs:
+	docker-compose logs -f app
+
+# Run tests
+test:
+	npm test
+
+# Run linter
+lint:
+	npm run lint
+
+# Clean up Docker resources
+clean:
+	docker-compose down -v --remove-orphans
+	docker system prune -f

package/templates/infra/nginx.conf.ejs

@@ -0,0 +1,25 @@
+events {
+    worker_connections 1024;
+}
+
+http {
+    upstream app_servers {
+        server app:3000;
+    }
+
+    server {
+        listen 80;
+        server_name localhost;
+
+        location / {
+            proxy_pass http://app_servers;
+            proxy_http_version 1.1;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection 'upgrade';
+            proxy_set_header Host $host;
+            proxy_cache_bypass $http_upgrade;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        }
+    }
+}

package/templates/middleware/errorHandler.js.ejs

@@ -31,6 +31,10 @@ const errorHandler = (err, req, res, next) => {
     const message = err.errors.map((e) => e.message).join(', ');
     error = new AppError(message, 400);
   }
+<% } %><% if (db === 'prisma') { %>
+  if (err.code === 'P2002') {
+    error = new AppError('Duplicate field value entered', 400);
+  }
 <% } %><% if (hasAuth) { %>
   if (err.name === 'JsonWebTokenError') {
     error = new AppError('Invalid token', 401);
@@ -41,9 +45,11 @@ const errorHandler = (err, req, res, next) => {
   }
 <% } %>
 
+  const message = error.isOperational ? error.message : 'Internal Server Error';
+
   res.status(error.statusCode || 500).json({
     success: false,
-    error: error.message || 'Internal Server Error',
+    error: process.env.NODE_ENV === 'development' ? (error.message || 'Internal Server Error') : message,
     ...(process.env.NODE_ENV === 'development' && { stack: err.stack }),
   });
 };

package/templates/middleware/validation.js.ejs

@@ -9,11 +9,11 @@ const { AppError } = require('../utils/errors');
  * Usage:
  *   router.post('/users', validate({ body: createUserSchema }), controller.create);
  */
-const validate = (schemas) => (req, res, next) => {
+const validate = (schemas) => async (req, res, next) => {
   const errors = [];
 
   for (const [source, schema] of Object.entries(schemas)) {
-    const result = schema.safeParse(req[source]);
+    const result = await schema.safeParseAsync(req[source]);
     if (!result.success) {
       result.error.issues.forEach((issue) => {
         errors.push(`${source}.${issue.path.join('.')}: ${issue.message}`);

package/templates/migrations/create-users.js.ejs

@@ -37,7 +37,11 @@ module.exports = {
         type: Sequelize.DATE,
         allowNull: false,
         defaultValue: Sequelize.literal('NOW()'),
-      },
+      },<% if (hasSoftDelete) { %>
+      deletedAt: {
+        type: Sequelize.DATE,
+        allowNull: true,
+      },<% } %>
     });
 
     await queryInterface.addIndex('users', ['email'], { unique: true });

package/templates/scaffold/controller.js.ejs

@@ -0,0 +1,94 @@
+const <%= resourceNameCamel %>Service = require('../services/<%= resourceNameCamel %>Service');
+const { AppError } = require('../utils/errors');
+const { success, created, paginated } = require('../utils/response');
+const { createLogger } = require('../utils/logger');
+
+const logger = createLogger('<%= resourceNamePascal %>Controller');
+
+const getAll<%= resourceNamePascal %>s = async (req, res, next) => {
+  try {
+    const page = Math.max(1, parseInt(req.query.page, 10) || 1);
+    const limit = Math.min(100, Math.max(1, parseInt(req.query.limit, 10) || 10));
+
+    logger.info('Fetching <%= resourceNamePlural %>', { page, limit });
+    const result = await <%= resourceNameCamel %>Service.getAll<%= resourceNamePascal %>s(page, limit);
+
+    return paginated(res, result.<%= resourceNamePlural %>, {
+      page,
+      limit,
+      total: result.total,
+      totalPages: result.totalPages,
+    });
+  } catch (error) {
+    logger.error('Error fetching <%= resourceNamePlural %>', { error: error.message });
+    next(error);
+  }
+};
+
+const get<%= resourceNamePascal %>ById = async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    const <%= resourceNameCamel %> = await <%= resourceNameCamel %>Service.get<%= resourceNamePascal %>ById(id);
+
+    if (!<%= resourceNameCamel %>) {
+      throw new AppError('<%= resourceNamePascal %> not found', 404);
+    }
+
+    return success(res, <%= resourceNameCamel %>);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const create<%= resourceNamePascal %> = async (req, res, next) => {
+  try {
+    const data = req.body;
+
+    logger.info('Creating <%= resourceNameCamel %>', { data });
+    const <%= resourceNameCamel %> = await <%= resourceNameCamel %>Service.create<%= resourceNamePascal %>(data);
+
+    return created(res, <%= resourceNameCamel %>);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const update<%= resourceNamePascal %> = async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    const data = req.body;
+
+    const <%= resourceNameCamel %> = await <%= resourceNameCamel %>Service.update<%= resourceNamePascal %>(id, data);
+
+    if (!<%= resourceNameCamel %>) {
+      throw new AppError('<%= resourceNamePascal %> not found', 404);
+    }
+
+    return success(res, <%= resourceNameCamel %>);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const delete<%= resourceNamePascal %> = async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    const deleted = await <%= resourceNameCamel %>Service.delete<%= resourceNamePascal %>(id);
+
+    if (!deleted) {
+      throw new AppError('<%= resourceNamePascal %> not found', 404);
+    }
+
+    return success(res, { message: '<%= resourceNamePascal %> deleted successfully' });
+  } catch (error) {
+    next(error);
+  }
+};
+
+module.exports = {
+  getAll<%= resourceNamePascal %>s,
+  get<%= resourceNamePascal %>ById,
+  create<%= resourceNamePascal %>,
+  update<%= resourceNamePascal %>,
+  delete<%= resourceNamePascal %>
+};

package/templates/scaffold/route.js.ejs

@@ -0,0 +1,88 @@
+const express = require('express');
+const <%= resourceNameCamel %>Controller = require('../controllers/<%= resourceNameCamel %>Controller');
+<% if (hasAuth) { %>const { authenticate } = require('../middleware/auth');<% } %>
+
+const router = express.Router();
+
+<% if (hasAuth) { %>// Apply authentication middleware to all routes
+router.use(authenticate);
+<% } %>
+/**
+ * @swagger
+ * /<%= resourceNamePlural %>:
+ *   get:
+ *     summary: Get all <%= resourceNamePlural %>
+ *     tags: [<%= resourceNamePascal %>]
+ *     responses:
+ *       200:
+ *         description: List of <%= resourceNamePlural %>
+ */
+router.get('/', <%= resourceNameCamel %>Controller.getAll<%= resourceNamePascal %>s);
+
+/**
+ * @swagger
+ * /<%= resourceNamePlural %>/{id}:
+ *   get:
+ *     summary: Get a <%= resourceNameCamel %> by ID
+ *     tags: [<%= resourceNamePascal %>]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: <%= resourceNamePascal %> details
+ */
+router.get('/:id', <%= resourceNameCamel %>Controller.get<%= resourceNamePascal %>ById);
+
+/**
+ * @swagger
+ * /<%= resourceNamePlural %>:
+ *   post:
+ *     summary: Create a new <%= resourceNameCamel %>
+ *     tags: [<%= resourceNamePascal %>]
+ *     responses:
+ *       201:
+ *         description: Created <%= resourceNameCamel %>
+ */
+router.post('/', <%= resourceNameCamel %>Controller.create<%= resourceNamePascal %>);
+
+/**
+ * @swagger
+ * /<%= resourceNamePlural %>/{id}:
+ *   put:
+ *     summary: Update a <%= resourceNameCamel %>
+ *     tags: [<%= resourceNamePascal %>]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: Updated <%= resourceNameCamel %>
+ */
+router.put('/:id', <%= resourceNameCamel %>Controller.update<%= resourceNamePascal %>);
+
+/**
+ * @swagger
+ * /<%= resourceNamePlural %>/{id}:
+ *   delete:
+ *     summary: Delete a <%= resourceNameCamel %>
+ *     tags: [<%= resourceNamePascal %>]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: <%= resourceNamePascal %> deleted successfully
+ */
+router.delete('/:id', <%= resourceNameCamel %>Controller.delete<%= resourceNamePascal %>);
+
+module.exports = router;

package/templates/scaffold/service.js.ejs

@@ -0,0 +1,77 @@
+const { createLogger } = require('../utils/logger');
+
+const logger = createLogger('<%= resourceNamePascal %>Service');
+
+/**
+ * Get all <%= resourceNamePlural %> with pagination
+ */
+const getAll<%= resourceNamePascal %>s = async (page = 1, limit = 10) => {
+  logger.info('Fetching all <%= resourceNamePlural %>', { page, limit });
+  
+  // TODO: Implement database logic here
+  // Example (Prisma): return prisma.<%= resourceNameCamel %>.findMany({ skip: (page - 1) * limit, take: limit });
+  // Example (Mongoose): return <%= resourceNamePascal %>.find().skip((page - 1) * limit).limit(limit);
+  
+  return {
+    <%= resourceNamePlural %>: [],
+    total: 0,
+    totalPages: 0,
+    currentPage: page,
+  };
+};
+
+/**
+ * Get <%= resourceNameCamel %> by ID
+ */
+const get<%= resourceNamePascal %>ById = async (id) => {
+  logger.info('Fetching <%= resourceNameCamel %> by ID', { id });
+  
+  // TODO: Implement database logic here
+  // Example (Prisma): return prisma.<%= resourceNameCamel %>.findUnique({ where: { id } });
+  
+  return null;
+};
+
+/**
+ * Create new <%= resourceNameCamel %>
+ */
+const create<%= resourceNamePascal %> = async (data) => {
+  logger.info('Creating new <%= resourceNameCamel %>');
+  
+  // TODO: Implement database logic here
+  // Example (Prisma): return prisma.<%= resourceNameCamel %>.create({ data });
+  
+  return { id: 'new-id', ...data };
+};
+
+/**
+ * Update <%= resourceNameCamel %> by ID
+ */
+const update<%= resourceNamePascal %> = async (id, data) => {
+  logger.info('Updating <%= resourceNameCamel %>', { id });
+  
+  // TODO: Implement database logic here
+  // Example (Prisma): return prisma.<%= resourceNameCamel %>.update({ where: { id }, data });
+  
+  return { id, ...data };
+};
+
+/**
+ * Delete <%= resourceNameCamel %> by ID
+ */
+const delete<%= resourceNamePascal %> = async (id) => {
+  logger.info('Deleting <%= resourceNameCamel %>', { id });
+  
+  // TODO: Implement database logic here
+  // Example (Prisma): await prisma.<%= resourceNameCamel %>.delete({ where: { id } });
+  
+  return true;
+};
+
+module.exports = {
+  getAll<%= resourceNamePascal %>s,
+  get<%= resourceNamePascal %>ById,
+  create<%= resourceNamePascal %>,
+  update<%= resourceNamePascal %>,
+  delete<%= resourceNamePascal %>,
+};

package/templates/services/authService.js.ejs

@@ -4,8 +4,19 @@ const crypto = require('crypto');
 <% } %>
 <% if (!hasRedis) { %>
 // In-memory token blacklist — replace with Redis for production.
-const tokenBlacklist = new Set();
+const tokenBlacklist = new Map(); // token → expiresAt
 const resetTokens = new Map(); // token → { email, expiresAt }
+
+// Periodic cleanup to prevent memory leaks
+setInterval(() => {
+  const now = Date.now();
+  for (const [token, expiresAt] of tokenBlacklist.entries()) {
+    if (expiresAt < now) tokenBlacklist.delete(token);
+  }
+  for (const [hash, entry] of resetTokens.entries()) {
+    if (entry.expiresAt < now) resetTokens.delete(hash);
+  }
+}, 60 * 60 * 1000).unref(); // Run every hour
 <% } %>
 const generateTokens = (user) => {
   const payload = {
@@ -66,10 +77,17 @@ const consumeResetToken = async (token) => {
 };
 <% } else { %>
 const blacklistToken = (token) => {
-  tokenBlacklist.add(token);
+  const decoded = jwt.decode(token);
+  const expiresAt = decoded && decoded.exp ? decoded.exp * 1000 : Date.now() + 86400000;
+  tokenBlacklist.set(token, expiresAt);
 };
 
 const isTokenBlacklisted = (token) => {
+  const expiresAt = tokenBlacklist.get(token);
+  if (expiresAt && expiresAt < Date.now()) {
+    tokenBlacklist.delete(token);
+    return false;
+  }
   return tokenBlacklist.has(token);
 };
 

package/templates/services/userService.prisma.js.ejs

@@ -58,12 +58,13 @@ const findAll = async ({ page = 1, limit = 20 } = {}) => {
   const skip = (page - 1) * limit;
   const [users, total] = await Promise.all([
     prisma.user.findMany({
-      select: { id: true, username: true, email: true, role: true, createdAt: true, updatedAt: true },
+<% if (hasSoftDelete) { %>      where: { deletedAt: null },
+<% } %>      select: { id: true, username: true, email: true, role: true, createdAt: true, updatedAt: true },
       orderBy: { createdAt: 'desc' },
       skip,
       take: limit,
     }),
-    prisma.user.count(),
+    prisma.user.count(<% if (hasSoftDelete) { %>{ where: { deletedAt: null } }<% } %>),
   ]);
   return { users, total, page, totalPages: Math.ceil(total / limit) };
 };

package/lib/ai-cli.js

@@ -1,133 +0,0 @@
-/**
- * AI CLI handler — interprets natural language project descriptions
- * and maps them to express-genix configuration flags.
- *
- * Requires @langchain/openai or @langchain/anthropic to be installed.
- * These are NOT bundled with express-genix to keep the CLI lightweight.
- *
- * Install with: npm install -g @langchain/core @langchain/openai
- */
-
-const SYSTEM_PROMPT = `You are an expert Express.js project configurator for the express-genix CLI tool.
-Given a natural language description of a web application, output a JSON configuration object.
-
-Available options:
-- projectName: string (lowercase, hyphens only, no spaces)
-- language: "javascript" | "typescript"
-- db: "mongodb" | "postgresql" | "prisma" | "none"
-- logger: "winston" | "pino"
-- features: array of feature strings from this list:
-  - "auth" (JWT authentication — requires a database)
-  - "rateLimit" (rate limiting)
-  - "swagger" (Swagger/OpenAPI docs)
-  - "redis" (Redis token blacklist — requires auth)
-  - "docker" (Docker & Docker Compose)
-  - "cicd" (GitHub Actions CI/CD)
-  - "websocket" (WebSocket via Socket.io)
-  - "requestId" (request ID / correlation tracking)
-  - "email" (Nodemailer email service — requires database)
-  - "fileUpload" (Multer file uploads)
-  - "softDelete" (soft deletes — requires database + auth)
-  - "auditLog" (audit logging middleware)
-  - "metrics" (Prometheus metrics)
-  - "apiVersioning" (API versioning /api/v1)
-  - "backgroundJobs" (BullMQ background jobs)
-  - "graphql" (GraphQL via Apollo Server)
-  - "mcp" (MCP Server — exposes API as AI-agent tools)
-  - "ai" (LangChain/LangGraph AI service)
-
-Rules:
-- Always include "auth", "rateLimit", "swagger", "requestId" unless explicitly unwanted
-- Include "docker" for production-ready apps
-- Include "ai" if the description mentions AI, chatbot, LLM, or intelligence
-- Include "mcp" if the description mentions AI agents, tools, or MCP
-- Choose "prisma" for modern stacks, "mongodb" for documents, "postgresql" for relational
-- Infer a short kebab-case project name from the description
-- Output ONLY valid JSON. No explanation, no markdown fences.`;
-
-const runAiCommand = async (description) => {
-  // Check for API key
-  const hasOpenAI = !!process.env.OPENAI_API_KEY;
-  const hasAnthropic = !!process.env.ANTHROPIC_API_KEY;
-  const hasGemini = !!process.env.GOOGLE_API_KEY;
-
-  if (!hasOpenAI && !hasAnthropic && !hasGemini) {
-    console.error('❌ The AI command requires an API key.');
-    console.error('   Set one of these environment variables:');
-    console.error('     export OPENAI_API_KEY=sk-...');
-    console.error('     export ANTHROPIC_API_KEY=sk-ant-...');
-    console.error('     export GOOGLE_API_KEY=AI...');
-    process.exit(1);
-  }
-
-  // Try to load LangChain (not bundled — must be installed separately)
-  let ChatModel;
-  try {
-    if (hasGemini) {
-      const { ChatGoogleGenerativeAI } = require('@langchain/google-genai');
-      ChatModel = new ChatGoogleGenerativeAI({
-        model: 'gemini-2.0-flash',
-        maxOutputTokens: 1024,
-        apiKey: process.env.GOOGLE_API_KEY,
-      });
-    } else if (hasAnthropic) {
-      const { ChatAnthropic } = require('@langchain/anthropic');
-      ChatModel = new ChatAnthropic({
-        modelName: 'claude-sonnet-4-20250514',
-        maxTokens: 1024,
-        anthropicApiKey: process.env.ANTHROPIC_API_KEY,
-      });
-    } else {
-      const { ChatOpenAI } = require('@langchain/openai');
-      ChatModel = new ChatOpenAI({
-        modelName: 'gpt-4o-mini',
-        maxTokens: 1024,
-        openAIApiKey: process.env.OPENAI_API_KEY,
-      });
-    }
-  } catch {
-    console.error('❌ LangChain packages not found.');
-    console.error('   Install them globally to use the AI command:');
-    console.error('     npm install -g @langchain/core @langchain/openai @langchain/anthropic @langchain/google-genai');
-    process.exit(1);
-  }
-
-  const { HumanMessage, SystemMessage } = require('@langchain/core/messages');
-
-  console.log('🤖 Analyzing your description...\n');
-
-  const response = await ChatModel.invoke([
-    new SystemMessage(SYSTEM_PROMPT),
-    new HumanMessage(description),
-  ]);
-
-  let config;
-  try {
-    const jsonMatch = response.content.match(/\{[\s\S]*\}/);
-    if (!jsonMatch) throw new Error('No JSON found in response');
-    config = JSON.parse(jsonMatch[0]);
-  } catch {
-    console.error('❌ Could not parse AI response. Try a clearer description.');
-    console.error('   Raw output:', response.content);
-    process.exit(1);
-  }
-
-  // Validate required fields
-  if (!config.projectName || !config.language || !config.db) {
-    console.error('❌ AI response missing required fields. Try again.');
-    process.exit(1);
-  }
-
-  // Display interpreted config
-  console.log('📋 Interpreted configuration:\n');
-  console.log(`   Project:    ${config.projectName}`);
-  console.log(`   Language:   ${config.language}`);
-  console.log(`   Database:   ${config.db}`);
-  console.log(`   Logger:     ${config.logger || 'winston'}`);
-  console.log(`   Features:   ${(config.features || []).join(', ') || 'base'}`);
-  console.log('');
-
-  return config;
-};
-
-module.exports = { runAiCommand };