express-genix 3.0.0 → 4.1.0

package/templates/agents/graph.js.ejs

@@ -0,0 +1,85 @@
+const { createReactAgent } = require('@langchain/langgraph/prebuilt');
+const { tool } = require('@langchain/core/tools');
+const { HumanMessage } = require('@langchain/core/messages');
+const { z } = require('zod');
+const { getModel } = require('../config/ai');
+
+// --- Built-in Tools ---
+
+const currentTimeTool = tool(
+  async () => new Date().toISOString(),
+  {
+    name: 'current_time',
+    description: 'Get the current date and time in ISO 8601 format',
+    schema: z.object({}),
+  }
+);
+
+const calculatorTool = tool(
+  async ({ expression }) => {
+    // Only allow digits and math operators — no code injection possible
+    const sanitized = expression.replace(/[^0-9+\-*/().%\s]/g, '');
+    if (sanitized !== expression.trim()) {
+      return 'Error: Expression contains invalid characters. Use only numbers and +, -, *, /, (, ), %';
+    }
+    try {
+      const result = new Function(`"use strict"; return (${sanitized})`)();
+      if (!isFinite(result)) return 'Error: Result is not a finite number';
+      return String(result);
+    } catch {
+      return 'Error: Could not evaluate expression';
+    }
+  },
+  {
+    name: 'calculator',
+    description: 'Evaluate a mathematical expression using standard operators: +, -, *, /, %',
+    schema: z.object({
+      expression: z.string().describe('Math expression, e.g. "2 + 3 * 4"'),
+    }),
+  }
+);
+
+/**
+ * Create a LangGraph ReAct agent with tool-calling capabilities.
+ *
+ * @param {Object} options
+ * @param {Array}  options.tools - Additional @langchain/core tools to register
+ * @param {string} options.systemPrompt - System instruction for the agent
+ * @param {string} options.provider - AI provider (openai, anthropic, ollama)
+ * @param {string} options.model - Model name override
+ */
+const createAgent = (options = {}) => {
+  const tools = [
+    currentTimeTool,
+    calculatorTool,
+    ...(options.tools || []),
+  ];
+
+  const model = getModel(options);
+
+  return createReactAgent({
+    llm: model,
+    tools,
+    messageModifier: options.systemPrompt || 'You are a helpful assistant. Use the provided tools when needed to answer questions accurately.',
+  });
+};
+
+/**
+ * Run the agent with a single message and return the final response.
+ */
+const runAgent = async (message, options = {}) => {
+  const agent = createAgent(options);
+
+  const result = await agent.invoke({
+    messages: [new HumanMessage(message)],
+  });
+
+  const lastMessage = result.messages[result.messages.length - 1];
+
+  return {
+    content: lastMessage.content,
+    steps: result.messages.length,
+  };
+};
+
+module.exports = { createAgent, runAgent, currentTimeTool, calculatorTool };

package/templates/config/ai.js.ejs

@@ -0,0 +1,54 @@
+const { ChatOpenAI } = require('@langchain/openai');
+const { ChatAnthropic } = require('@langchain/anthropic');
+const { ChatOllama } = require('@langchain/ollama');
+const { ChatGoogleGenerativeAI } = require('@langchain/google-genai');
+
+/**
+ * Create a LangChain chat model based on the configured provider.
+ * Supports OpenAI, Anthropic, Google Gemini, and Ollama (local).
+ */
+const getModel = (options = {}) => {
+  const provider = (options.provider || process.env.AI_PROVIDER || 'openai').toLowerCase();
+  const temperature = options.temperature ?? parseFloat(process.env.AI_TEMPERATURE || '0.7');
+  const maxTokens = options.maxTokens ?? parseInt(process.env.AI_MAX_TOKENS || '2048', 10);
+
+  switch (provider) {
+    case 'openai':
+      return new ChatOpenAI({
+        modelName: options.model || process.env.AI_MODEL || 'gpt-4o-mini',
+        temperature,
+        maxTokens,
+        openAIApiKey: process.env.OPENAI_API_KEY,
+      });
+
+    case 'anthropic':
+      return new ChatAnthropic({
+        modelName: options.model || process.env.AI_MODEL || 'claude-sonnet-4-20250514',
+        temperature,
+        maxTokens,
+        anthropicApiKey: process.env.ANTHROPIC_API_KEY,
+      });
+
+    case 'gemini':
+      return new ChatGoogleGenerativeAI({
+        model: options.model || process.env.AI_MODEL || 'gemini-2.0-flash',
+        temperature,
+        maxOutputTokens: maxTokens,
+        apiKey: process.env.GOOGLE_API_KEY,
+      });
+
+    case 'ollama':
+      return new ChatOllama({
+        model: options.model || process.env.AI_MODEL || 'llama3',
+        temperature,
+        baseUrl: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
+      });
+
+    default:
+      throw new Error(
+        `Unsupported AI provider: "${provider}". Supported: openai, anthropic, gemini, ollama`
+      );
+  }
+};
+
+module.exports = { getModel };

package/templates/controllers/aiController.js.ejs

@@ -0,0 +1,102 @@
+const aiService = require('../services/aiService');
+const { runAgent } = require('../agents/graph');
+const { success, error } = require('../utils/response');
+
+/**
+ * POST /ai/chat — Send a message, get a complete AI response.
+ */
+const chatHandler = async (req, res, next) => {
+  try {
+    const { message, systemPrompt, history, provider, model, temperature, maxTokens } = req.body;
+
+    if (!message) {
+      return res.status(400).json(error('Message is required'));
+    }
+
+    const result = await aiService.chat(message, {
+      systemPrompt,
+      history,
+      provider,
+      model,
+      temperature,
+      maxTokens,
+    });
+
+    res.json(success(result));
+  } catch (err) {
+    next(err);
+  }
+};
+
+/**
+ * POST /ai/stream — Stream an AI response via Server-Sent Events.
+ */
+const streamHandler = async (req, res, next) => {
+  try {
+    const { message, systemPrompt, history, provider, model, temperature, maxTokens } = req.body;
+
+    if (!message) {
+      return res.status(400).json(error('Message is required'));
+    }
+
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+
+    const generator = aiService.stream(message, {
+      systemPrompt,
+      history,
+      provider,
+      model,
+      temperature,
+      maxTokens,
+    });
+
+    for await (const chunk of generator) {
+      res.write(`data: ${JSON.stringify({ content: chunk })}\n\n`);
+    }
+
+    res.write('data: [DONE]\n\n');
+    res.end();
+  } catch (err) {
+    next(err);
+  }
+};
+
+/**
+ * POST /ai/chain — Run a prompt template chain with variables.
+ */
+const chainHandler = async (req, res, next) => {
+  try {
+    const { template, variables, provider, model } = req.body;
+
+    if (!template) {
+      return res.status(400).json(error('Template is required'));
+    }
+
+    const result = await aiService.chain(template, variables || {}, { provider, model });
+    res.json(success({ content: result }));
+  } catch (err) {
+    next(err);
+  }
+};
+
+/**
+ * POST /ai/agent — Run the LangGraph ReAct agent.
+ */
+const agentHandler = async (req, res, next) => {
+  try {
+    const { message, systemPrompt, provider, model } = req.body;
+
+    if (!message) {
+      return res.status(400).json(error('Message is required'));
+    }
+
+    const result = await runAgent(message, { systemPrompt, provider, model });
+    res.json(success(result));
+  } catch (err) {
+    next(err);
+  }
+};
+
+module.exports = { chatHandler, streamHandler, chainHandler, agentHandler };

package/templates/core/env.ejs

@@ -28,6 +28,19 @@ FRONTEND_URL=http://localhost:3000
 # File Uploads
 UPLOAD_DIR=uploads
 UPLOAD_MAX_SIZE=5242880
+<% } %><% if (hasMCP) { %>
+# MCP Server
+MCP_SERVER_NAME=<%= projectName %>
+<% } %><% if (hasAI) { %>
+# AI Service (LangChain)
+AI_PROVIDER=openai
+AI_MODEL=gpt-4o-mini
+AI_TEMPERATURE=0.7
+AI_MAX_TOKENS=2048
+OPENAI_API_KEY=
+# ANTHROPIC_API_KEY=
+# GOOGLE_API_KEY=
+# OLLAMA_BASE_URL=http://localhost:11434
 <% } %><% if (db === 'mongodb') { %>
 # Database
 MONGO_URI=mongodb://localhost:27017/<%= projectName %>

package/templates/core/env.example.ejs

@@ -28,6 +28,19 @@ FRONTEND_URL=http://localhost:3000
 # File Uploads
 UPLOAD_DIR=uploads
 UPLOAD_MAX_SIZE=5242880
+<% } %><% if (hasMCP) { %>
+# MCP Server
+MCP_SERVER_NAME=<%= projectName %>
+<% } %><% if (hasAI) { %>
+# AI Service (LangChain)
+AI_PROVIDER=openai
+AI_MODEL=gpt-4o-mini
+AI_TEMPERATURE=0.7
+AI_MAX_TOKENS=2048
+OPENAI_API_KEY=
+# ANTHROPIC_API_KEY=
+# GOOGLE_API_KEY=
+# OLLAMA_BASE_URL=http://localhost:11434
 <% } %><% if (db === 'mongodb') { %>
 # Database
 MONGO_URI=mongodb://localhost:27017/<%= projectName %>

package/templates/core/package.json.ejs

@@ -18,7 +18,8 @@
     "db:migrate": "npx sequelize-cli db:migrate",
     "db:migrate:undo": "npx sequelize-cli db:migrate:undo",
     "db:seed": "npx sequelize-cli db:seed:all",
-    "db:create": "npx sequelize-cli db:create"<% } %>
+    "db:create": "npx sequelize-cli db:create"<% } %><% if (hasMCP) { %>,
+    "mcp:start": "node src/mcp/server.js"<% } %>
   },
   "dependencies": {
     "express": "^4.21.0",
@@ -31,7 +32,7 @@
     "swagger-ui-express": "^5.0.1"<% } %><% if (hasAuth) { %>,
     "jsonwebtoken": "^9.0.2",
     "bcryptjs": "^2.4.3",
-    "validator": "^13.12.0",
+    "validator": "^13.12.0"<% } %><% if (hasAuth || hasMCP || hasAI) { %>,
     "zod": "^3.23.0"<% } %><% if (db === 'mongodb') { %>,
     "mongoose": "^8.8.0"<% } %><% if (db === 'postgresql') { %>,
     "pg": "^8.13.0",
@@ -46,7 +47,14 @@
     "@apollo/server": "^4.11.0",
     "graphql": "^16.9.0",
     "graphql-tag": "^2.12.6"<% } %><% if (hasBackgroundJobs) { %>,
-    "bullmq": "^5.12.0"<% } %><% if (logger === 'winston') { %>,
+    "bullmq": "^5.12.0"<% } %><% if (hasMCP) { %>,
+    "@modelcontextprotocol/sdk": "^1.12.0"<% } %><% if (hasAI) { %>,
+    "@langchain/core": "^0.3.0",
+    "@langchain/openai": "^0.5.0",
+    "@langchain/anthropic": "^0.3.0",
+    "@langchain/google-genai": "^0.2.0",
+    "@langchain/ollama": "^0.1.0",
+    "@langchain/langgraph": "^0.2.0"<% } %><% if (logger === 'winston') { %>,
     "winston": "^3.15.0"<% } %><% if (logger === 'pino') { %>,
     "pino": "^9.5.0",
     "pino-pretty": "^13.0.0"<% } %>

package/templates/mcp/mcp-config.json.ejs

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "<%= projectName %>": {
+      "command": "node",
+      "args": ["src/mcp/server.js"],
+      "cwd": "/path/to/<%= projectName %>"
+    }
+  }
+}

package/templates/mcp/server.js.ejs

@@ -0,0 +1,151 @@
+require('dotenv').config();
+
+const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { z } = require('zod');
+<% if (hasDatabase) { %>const db = require('../config/database');
+<% } %><% if (hasAuth) { %>const userService = require('../services/userService');
+<% } %><% if (!hasAuth && !isNoDatabase) { %>const exampleService = require('../services/exampleService');
+<% } %><% if (hasEmail) { %>const emailService = require('../services/emailService');
+<% } %>
+
+const server = new McpServer({
+  name: process.env.MCP_SERVER_NAME || '<%= projectName %>',
+  version: '1.0.0',
+});
+
+<% if (hasAuth) { %>
+// --- User Management Tools ---
+
+server.tool(
+  'list_users',
+  'List all registered users with pagination',
+  {
+    page: z.number().optional().describe('Page number (default: 1)'),
+    limit: z.number().optional().describe('Items per page (default: 20)'),
+  },
+  async ({ page = 1, limit = 20 }) => {
+    const result = await userService.findAll({ page, limit });
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+  }
+);
+
+server.tool(
+  'get_user',
+  'Get a user by their ID',
+  {
+    userId: z.string().describe('The user ID to look up'),
+  },
+  async ({ userId }) => {
+    const user = await userService.findById(userId);
+    if (!user) {
+      return { content: [{ type: 'text', text: 'User not found' }], isError: true };
+    }
+    const { password, ...safeUser } = user.toJSON ? user.toJSON() : user;
+    return { content: [{ type: 'text', text: JSON.stringify(safeUser, null, 2) }] };
+  }
+);
+
+server.tool(
+  'register_user',
+  'Register a new user account',
+  {
+    username: z.string().describe('Username for the new account'),
+    email: z.string().email().describe('Email address'),
+    password: z.string().min(8).describe('Password (min 8 characters)'),
+  },
+  async ({ username, email, password }) => {
+    const bcrypt = require('bcryptjs');
+    const existing = await userService.findByEmail(email);
+    if (existing) {
+      return { content: [{ type: 'text', text: 'A user with this email already exists' }], isError: true };
+    }
+    const hashedPassword = await bcrypt.hash(password, 12);
+    const user = await userService.create({ username, email, password: hashedPassword });
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ id: user.id, username: user.username, email: user.email, role: user.role || 'user' }, null, 2),
+      }],
+    };
+  }
+);
+<% } %>
+<% if (!hasAuth) { %>
+// --- Example CRUD Tools ---
+
+server.tool(
+  'list_examples',
+  'List all example items with pagination',
+  {
+    page: z.number().optional().describe('Page number (default: 1)'),
+    limit: z.number().optional().describe('Items per page (default: 20)'),
+  },
+  async ({ page = 1, limit = 20 }) => {
+    const result = await exampleService.getAll({ page, limit });
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+  }
+);
+
+server.tool(
+  'create_example',
+  'Create a new example item',
+  {
+    title: z.string().describe('Item title'),
+    description: z.string().optional().describe('Item description'),
+  },
+  async ({ title, description }) => {
+    const item = await exampleService.create({ title, description });
+    return { content: [{ type: 'text', text: JSON.stringify(item, null, 2) }] };
+  }
+);
+<% } %>
+<% if (hasEmail) { %>
+// --- Email Tools ---
+
+server.tool(
+  'send_email',
+  'Send an email to a recipient',
+  {
+    to: z.string().email().describe('Recipient email address'),
+    subject: z.string().describe('Email subject line'),
+    html: z.string().describe('Email body in HTML format'),
+  },
+  async ({ to, subject, html }) => {
+    const info = await emailService.sendMail({ to, subject, html });
+    return { content: [{ type: 'text', text: `Email sent successfully (ID: ${info.messageId})` }] };
+  }
+);
+<% } %>
+
+// --- Health Check Tool ---
+
+server.tool(
+  'health_check',
+  'Check the application health and status',
+  {},
+  async () => {
+    const health = {
+      status: 'OK',
+      uptime: `${Math.floor(process.uptime())}s`,
+      memoryUsage: `${Math.round(process.memoryUsage().rss / 1024 / 1024)} MB`,
+      timestamp: new Date().toISOString(),
+    };
+    return { content: [{ type: 'text', text: JSON.stringify(health, null, 2) }] };
+  }
+);
+
+// --- Start MCP Server ---
+
+const main = async () => {
+<% if (hasDatabase) { %>  await db.connect();
+<% } %>
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`MCP server "${process.env.MCP_SERVER_NAME || '<%= projectName %>'}" running on stdio`);
+};
+
+main().catch((err) => {
+  console.error('Failed to start MCP server:', err);
+  process.exit(1);
+});

package/templates/middleware/auditLog.js.ejs

@@ -1,4 +1,4 @@
-const logger = require('../utils/logger');
+const { logger } = require('../utils/logger');
 
 /**
  * Audit Logging Middleware
@@ -47,10 +47,12 @@ const auditLog = (action) => (req, res, next) => {
       }
     }
 
+    const message = `${auditEntry.method} ${auditEntry.path} ${auditEntry.statusCode} ${auditEntry.duration}`;
+
     if (res.statusCode >= 400) {
-      logger.warn(auditEntry);
+      logger.warn(message, auditEntry);
     } else {
-      logger.info(auditEntry);
+      logger.info(message, auditEntry);
     }
 
     originalEnd.apply(res, args);

package/templates/routes/aiRoutes.js.ejs

@@ -0,0 +1,126 @@
+const express = require('express');
+const { chatHandler, streamHandler, chainHandler, agentHandler } = require('../controllers/aiController');
+
+const router = express.Router();
+
+/**
+ * @swagger
+ * /api<% if (hasApiVersioning) { %>/v1<% } %>/ai/chat:
+ *   post:
+ *     summary: Send a chat message to the AI
+ *     tags: [AI]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [message]
+ *             properties:
+ *               message:
+ *                 type: string
+ *                 example: "What is Node.js?"
+ *               systemPrompt:
+ *                 type: string
+ *                 example: "You are a helpful coding assistant."
+ *               history:
+ *                 type: array
+ *                 items:
+ *                   type: object
+ *                   properties:
+ *                     role:
+ *                       type: string
+ *                       enum: [user, assistant]
+ *                     content:
+ *                       type: string
+ *               provider:
+ *                 type: string
+ *                 enum: [openai, anthropic, gemini, ollama]
+ *               model:
+ *                 type: string
+ *     responses:
+ *       200:
+ *         description: AI response
+ */
+router.post('/chat', chatHandler);
+
+/**
+ * @swagger
+ * /api<% if (hasApiVersioning) { %>/v1<% } %>/ai/stream:
+ *   post:
+ *     summary: Stream an AI response via Server-Sent Events
+ *     tags: [AI]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [message]
+ *             properties:
+ *               message:
+ *                 type: string
+ *     responses:
+ *       200:
+ *         description: SSE stream of AI response chunks
+ */
+router.post('/stream', streamHandler);
+
+/**
+ * @swagger
+ * /api<% if (hasApiVersioning) { %>/v1<% } %>/ai/chain:
+ *   post:
+ *     summary: Run a prompt template chain with variable substitution
+ *     tags: [AI]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [template]
+ *             properties:
+ *               template:
+ *                 type: string
+ *                 example: "Summarize the following text: {text}"
+ *               variables:
+ *                 type: object
+ *                 example: { "text": "Node.js is a JavaScript runtime..." }
+ *               provider:
+ *                 type: string
+ *                 enum: [openai, anthropic, gemini, ollama]
+ *     responses:
+ *       200:
+ *         description: Chain result
+ */
+router.post('/chain', chainHandler);
+
+/**
+ * @swagger
+ * /api<% if (hasApiVersioning) { %>/v1<% } %>/ai/agent:
+ *   post:
+ *     summary: Run the LangGraph ReAct agent with tool calling
+ *     tags: [AI]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [message]
+ *             properties:
+ *               message:
+ *                 type: string
+ *                 example: "What time is it right now?"
+ *               systemPrompt:
+ *                 type: string
+ *               provider:
+ *                 type: string
+ *                 enum: [openai, anthropic, gemini, ollama]
+ *     responses:
+ *       200:
+ *         description: Agent response with tool-use steps
+ */
+router.post('/agent', agentHandler);
+
+module.exports = router;

package/templates/routes/index.js.ejs

@@ -5,6 +5,7 @@ const adminRoutes = require('./adminRoutes');
 <% } else { %>const exampleRoutes = require('./exampleRoutes');
 <% } %><% if (hasFileUpload) { %>const uploadRoutes = require('./uploadRoutes');
 <% } %><% if (hasBackgroundJobs) { %>const jobRoutes = require('./jobRoutes');
+<% } %><% if (hasAI) { %>const aiRoutes = require('./aiRoutes');
 <% } %>
 
 const router = express.Router();
@@ -15,6 +16,7 @@ router.use('/admin', adminRoutes);
 <% } else { %>router.use('/examples', exampleRoutes);
 <% } %><% if (hasFileUpload) { %>router.use('/uploads', uploadRoutes);
 <% } %><% if (hasBackgroundJobs) { %>router.use('/jobs', jobRoutes);
+<% } %><% if (hasAI) { %>router.use('/ai', aiRoutes);
 <% } %>
 
 /**