outlet-orm 6.5.0 → 9.0.0

package/README.md

@@ -197,7 +197,14 @@ async store(req, res) {
 - **Raw queries**: `executeRawQuery()` and `execute()` (native driver results)
 - **Complete Migrations** (create/alter/drop, index, foreign keys, batch tracking)
 - **Database Backup** (v6.0.0): full/partial/journal backups, recurring scheduler, AES-256-GCM encryption, TCP daemon + remote client, automatic restore
-- **Handy CLI tools**: `outlet-init`, `outlet-migrate`, `outlet-convert`
+- **🤖 AiBridge** (v8.0.0): Multi-provider LLM abstraction — chat, stream, embeddings, images, TTS, STT with 9+ providers
+- **🤖 AI Query Builder** (v8.0.0): Natural language → SQL with schema introspection
+- **🤖 AI Seeder** (v8.0.0): LLM-powered realistic, domain-specific data generation
+- **🤖 AI Query Optimizer** (v8.0.0): SQL analysis, optimization, and index recommendations
+- **🤖 AI Prompt Enhancer** (v8.0.0): Schema/model/migration generation from natural language
+- **🤖 MCP Server** (v7.0.0): Model Context Protocol for AI agent integration (13 tools)
+- **🤖 AI Safety Guardrails** (v7.0.0): Automatic AI agent detection + destructive operation protection
+- **Handy CLI tools**: `outlet-init`, `outlet-migrate`, `outlet-convert`, `outlet-mcp`
 - **`.env` configuration** (loaded automatically)
 - **Multi-database**: MySQL, PostgreSQL, and SQLite
 - **Complete TypeScript types** with Generic Model and typed Schema Builder (v4.0.0+)
@@ -1220,6 +1227,126 @@ outlet-convert
 - ✅ Automatic timestamps support
 - ✅ Class names converted to PascalCase
 
+## 🤖 AI Integration
+
+Outlet ORM includes a complete AI subsystem with multi-provider LLM support and ORM-specific AI features.
+
+📚 **[Complete AI documentation available in `/docs`](./docs/AI_BRIDGE.md)**
+
+### AiBridge — Multi-Provider LLM Abstraction
+
+```javascript
+const { AiBridgeManager } = require('outlet-orm');
+
+const ai = new AiBridgeManager({
+  providers: {
+    openai: { api_key: process.env.OPENAI_API_KEY, model: 'gpt-4o' },
+    claude: { api_key: process.env.ANTHROPIC_API_KEY, model: 'claude-sonnet-4-20250514' },
+    ollama: { endpoint: 'http://localhost:11434', model: 'llama3' }
+  }
+});
+
+// Chat with any provider
+const response = await ai.chat('openai', [
+  { role: 'user', content: 'What is Node.js?' }
+]);
+
+// Fluent TextBuilder
+const { text } = await ai.text()
+  .using('openai', 'gpt-4o')
+  .withSystemPrompt('You are a helpful assistant.')
+  .withPrompt('Explain closures in JavaScript.')
+  .asText();
+
+// Stream responses
+for await (const chunk of ai.stream('claude', messages)) {
+  process.stdout.write(chunk.text || '');
+}
+
+// Embeddings, images, TTS, STT
+const embeddings = await ai.embeddings('openai', ['Hello world']);
+const image = await ai.image('openai', 'A sunset over mountains');
+```
+
+**Supported providers**: OpenAI, Claude, Gemini, Ollama, Grok, Mistral, ONN, Custom OpenAI, OpenRouter
+
+### AI Query Builder — Natural Language → SQL
+
+```javascript
+const { AIQueryBuilder } = require('outlet-orm');
+
+const qb = new AIQueryBuilder(ai, db);
+
+// Ask in natural language, get SQL + results
+const result = await qb.query('How many users signed up last month?');
+console.log(result.sql);     // SELECT COUNT(*) FROM users WHERE ...
+console.log(result.results); // [{ count: 42 }]
+
+// Generate SQL without executing
+const { sql } = await qb.toSql('Show me the top 5 users by post count');
+```
+
+### AI Seeder — Realistic Data Generation
+
+```javascript
+const { AISeeder } = require('outlet-orm');
+
+const seeder = new AISeeder(ai, db);
+
+// Generate and insert realistic data
+await seeder.seed('products', 20, {
+  domain: 'e-commerce',
+  locale: 'fr_FR',
+  description: 'Fashion store for young adults'
+});
+```
+
+### AI Query Optimizer
+
+```javascript
+const { AIQueryOptimizer } = require('outlet-orm');
+
+const optimizer = new AIQueryOptimizer(ai, db);
+const result = await optimizer.optimize(
+  'SELECT * FROM orders WHERE user_id IN (SELECT id FROM users WHERE status = "active")'
+);
+
+console.log(result.optimized);   // Rewritten SQL
+console.log(result.suggestions); // [{ type: 'index', impact: 'high', ... }]
+console.log(result.indexes);     // ['CREATE INDEX idx_...']
+```
+
+### MCP Server — AI Agent Integration
+
+```bash
+# Start MCP server for AI editors
+npx outlet-mcp
+```
+
+Configure your AI editor:
+
+```json
+{
+  "mcpServers": {
+    "outlet-orm": {
+      "command": "npx",
+      "args": ["outlet-mcp"]
+    }
+  }
+}
+```
+
+**13 MCP tools**: migrations, schema introspection, queries, seeds, backups, AI query, query optimization
+
+📖 Full documentation:
+- [AiBridge Manager](docs/AI_BRIDGE.md) — Multi-provider LLM abstraction
+- [AI Query Builder](docs/AI_QUERY.md) — Natural language to SQL
+- [AI Seeder](docs/AI_SEEDER.md) — Realistic data generation
+- [AI Query Optimizer](docs/AI_OPTIMIZER.md) — SQL optimization
+- [AI Prompt Enhancer](docs/AI_PROMPT.md) — Schema/code generation
+- [MCP Server](docs/MCP.md) — AI agent integration
+- [AI Safety Guardrails](docs/AI_SAFETY.md) — Destructive operation protection
+
 ## 📚 Documentation
 
 - [Migrations Guide](docs/MIGRATIONS.md)
@@ -1227,7 +1354,8 @@ outlet-convert
 - [Relation Detection](docs/RELATIONS_DETECTION.md)
 - [Quick Start Guide](docs/QUICKSTART.md)
 - [Architecture](docs/ARCHITECTURE.md)
-- [**TypeScript (complet)**](docs/TYPESCRIPT.md)
+- [**TypeScript (complete)**](docs/TYPESCRIPT.md)
+- [**AI Integration (complete)**](docs/AI_BRIDGE.md)
 
 ## 📘 TypeScript Support
 

package/bin/init.js

@@ -16,7 +16,129 @@ const rl = readline.createInterface({
 
 const question = (query) => new Promise((resolve) => rl.question(query, resolve));
 
+// ─── Parse CLI flags ─────────────────────────────────────────────
+
+function parseInitFlags(argv) {
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--prompt' || arg === '-P') {
+      flags.prompt = argv[++i];
+    } else if (arg === '--driver' || arg === '-d') {
+      flags.driver = argv[++i];
+    }
+  }
+  return flags;
+}
+
+// ─── Prompt-based init (v7.0.0) ─────────────────────────────────
+
+async function initFromPrompt(promptText, driverName) {
+  const PromptGenerator = require('../src/AI/PromptGenerator');
+
+  console.log('\n🤖 Outlet ORM — Prompt-based Initialization\n');
+  console.log(`  Prompt: "${promptText}"`);
+
+  const blueprint = PromptGenerator.parse(promptText);
+  console.log(`  Domain detected: ${blueprint.domain} (score: ${blueprint.score})`);
+  console.log(`  Tables: ${Object.keys(blueprint.tables).join(', ')}\n`);
+
+  // Determine the driver
+  const driver = driverName || 'sqlite';
+  const driverConfig = {
+    mysql:    { package: 'mysql2',  port: 3306 },
+    postgres: { package: 'pg',      port: 5432 },
+    sqlite:   { package: 'sqlite3', port: null }
+  };
+
+  if (!driverConfig[driver]) {
+    console.error(`❌ Unknown driver: ${driver}. Use mysql, postgres, or sqlite.`);
+    process.exit(1);
+  }
+
+  const cwd = process.cwd();
+
+  // Create directory structure
+  const directories = ['database/migrations', 'database/seeds', 'models', 'config'];
+  for (const dir of directories) {
+    const dirPath = path.join(cwd, dir);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+      console.log(`  📁 ${dir}/`);
+    }
+  }
+
+  // Generate database config
+  let config;
+  if (driver === 'sqlite') {
+    config = { driver: 'sqlite', database: './database.sqlite' };
+  } else {
+    config = {
+      driver,
+      host: 'localhost',
+      port: driverConfig[driver].port,
+      database: 'my_app',
+      user: 'root',
+      password: ''
+    };
+  }
+
+  const configContent = `const { DatabaseConnection } = require('outlet-orm');\n\nconst db = new DatabaseConnection(${JSON.stringify(config, null, 2)});\n\nmodule.exports = db;\n`;
+  const configPath = path.join(cwd, 'database', 'config.js');
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, configContent);
+    console.log('  ✅ database/config.js');
+  }
+
+  // Generate .env
+  const envPath = path.join(cwd, '.env');
+  if (!fs.existsSync(envPath)) {
+    const envLines = [`DB_DRIVER=${config.driver}`];
+    if (driver !== 'sqlite') {
+      envLines.push(`DB_HOST=${config.host}`, `DB_PORT=${config.port}`, `DB_USER=${config.user}`, `DB_PASSWORD=${config.password}`, `DB_DATABASE=${config.database}`);
+    } else {
+      envLines.push(`DB_FILE=${config.database}`);
+    }
+    fs.writeFileSync(envPath, envLines.join('\n') + '\n');
+    console.log('  ✅ .env');
+  }
+
+  // Generate models
+  console.log('\n📊 Generating models...');
+  const modelFiles = PromptGenerator.generateModels(blueprint, path.join(cwd, 'models'));
+  for (const f of modelFiles) {
+    console.log(`  ✅ ${path.relative(cwd, f)}`);
+  }
+
+  // Generate migrations
+  console.log('\n📦 Generating migrations...');
+  const migrationFiles = PromptGenerator.generateMigrations(blueprint, path.join(cwd, 'database', 'migrations'));
+  for (const f of migrationFiles) {
+    console.log(`  ✅ ${path.relative(cwd, f)}`);
+  }
+
+  // Generate seeder
+  console.log('\n🌱 Generating seeder...');
+  const seederFile = PromptGenerator.generateSeeder(blueprint, path.join(cwd, 'database', 'seeds'));
+  console.log(`  ✅ ${path.relative(cwd, seederFile)}`);
+
+  console.log('\n✨ Project generated from prompt!\n');
+  console.log('Next steps:');
+  console.log('  1. Review generated models in models/');
+  console.log('  2. Review migrations in database/migrations/');
+  console.log('  3. Run migrations: outlet-migrate migrate');
+  console.log(`  4. Install driver: npm install ${driverConfig[driver].package}`);
+}
+
 async function init() {
+  // Check for --prompt flag
+  const flags = parseInitFlags(process.argv.slice(2));
+  if (flags.prompt) {
+    await initFromPrompt(flags.prompt, flags.driver);
+    rl.close();
+    return;
+  }
+
   console.log('\n🚀 Bienvenue dans l\'assistant de configuration Outlet ORM!\n');
 
   try {

package/bin/mcp.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+/**
+ * outlet-mcp — MCP Server CLI entry point
+ * Starts the Outlet ORM MCP server on stdio for AI agent integration.
+ *
+ * Usage:
+ *   npx outlet-mcp                  # Start the MCP server
+ *   npx outlet-mcp --project /path  # Start with custom project directory
+ *   npx outlet-mcp --no-safety      # Disable AI safety guardrails
+ *
+ * @since 7.0.0
+ */
+
+const MCPServer = require('../src/AI/MCPServer');
+
+// ─── Parse CLI flags ─────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+const options = {};
+
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  if (arg === '--project' || arg === '-p') {
+    options.projectDir = args[++i];
+  } else if (arg === '--no-safety') {
+    options.safetyGuardrails = false;
+  } else if (arg === '--help' || arg === '-h') {
+    console.error(`
+outlet-mcp — Outlet ORM MCP Server
+
+Usage:
+  outlet-mcp [options]
+
+Options:
+  --project, -p <path>  Project root directory (default: cwd)
+  --no-safety           Disable AI safety guardrails
+  --help, -h            Show this help message
+
+The server communicates over stdio using the Model Context Protocol (MCP).
+It exposes tools for migrations, schema introspection, queries, seeds, and backups.
+
+Documentation: https://github.com/omgbwa-yasse/outlet-orm/blob/main/docs/MCP.md
+`);
+    process.exit(0);
+  }
+}
+
+// ─── Start ───────────────────────────────────────────────────────
+
+const server = new MCPServer(options);
+
+server.on('started', () => {
+  process.stderr.write('[outlet-mcp] MCP server started on stdio\n');
+});
+
+server.on('initialized', () => {
+  process.stderr.write('[outlet-mcp] Client connected and initialized\n');
+});
+
+server.on('close', async () => {
+  process.stderr.write('[outlet-mcp] Shutting down...\n');
+  await server.close();
+  process.exit(0);
+});
+
+// Graceful shutdown
+process.on('SIGINT', async () => {
+  await server.close();
+  process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+  await server.close();
+  process.exit(0);
+});
+
+server.start();

package/bin/migrate.js

@@ -8,6 +8,7 @@
 const readline = require('readline');
 const fs = require('fs').promises;
 const path = require('path');
+const AISafetyGuardrails = require('../src/AI/AISafetyGuardrails');
 
 const rl = readline.createInterface({
   input: process.stdin,
@@ -367,6 +368,14 @@ async function runNonInteractive(cmd, flags) {
     }
 
     case 'reset': {
+      // AI Safety Guardrails check (v7.0.0)
+      if (AISafetyGuardrails.isDestructiveCommand('reset')) {
+        const check = AISafetyGuardrails.validateDestructiveAction('reset', flags);
+        if (!check.allowed) {
+          console.error(check.message);
+          return;
+        }
+      }
       if (flags.yes || flags.force) {
         await manager.reset();
       } else {
@@ -376,6 +385,14 @@ async function runNonInteractive(cmd, flags) {
     }
 
     case 'refresh': {
+      // AI Safety Guardrails check (v7.0.0)
+      if (AISafetyGuardrails.isDestructiveCommand('fresh')) {
+        const check = AISafetyGuardrails.validateDestructiveAction('refresh', flags);
+        if (!check.allowed) {
+          console.error(check.message);
+          return;
+        }
+      }
       if (flags.yes || flags.force) {
         await manager.refresh();
       } else {
@@ -385,6 +402,14 @@ async function runNonInteractive(cmd, flags) {
     }
 
     case 'fresh': {
+      // AI Safety Guardrails check (v7.0.0)
+      if (AISafetyGuardrails.isDestructiveCommand('fresh')) {
+        const check = AISafetyGuardrails.validateDestructiveAction('fresh', flags);
+        if (!check.allowed) {
+          console.error(check.message);
+          return;
+        }
+      }
       if (flags.yes || flags.force) {
         await manager.fresh();
       } else {