overmind-mcp 2.0.0 → 2.0.2

package/scripts/setup-overmind-db.mjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+/**
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * SETUP OVERMIND DATABASE (PostgreSQL Existant)
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * Script qui initialise la base de données OverMind dans votre PostgreSQL existant
+ *
+ * Prérequis:
+ *   - PostgreSQL + pgvector déjà en Docker (container: postgres-pgvector)
+ *   - Node.js installé
+ *
+ * Usage:
+ *   node scripts/setup-overmind-db.js
+ * ═══════════════════════════════════════════════════════════════════════════════
+ */
+
+import { Client } from 'pg';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONFIGURATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const DB_CONFIG = {
+  host: process.env.POSTGRES_HOST || 'localhost',
+  port: parseInt(process.env.POSTGRES_PORT || '5432', 10),
+  user: process.env.POSTGRES_USER || 'postgres',
+  password: process.env.POSTGRES_PASSWORD || 'postgres',
+  database: 'postgres', // Se connecter à postgres pour créer la DB
+};
+
+const OVERMIND_DB_NAME = 'overmind_memory';
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FUNCTIONS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function checkPgVectorExtension(client) {
+  console.log('🔍 Vérification extension pgvector...');
+
+  try {
+    const res = await client.query(`
+      SELECT 1 FROM pg_available_extensions
+      WHERE name = 'vector'
+    `);
+
+    if (res.rows.length === 0) {
+      console.error('❌ pgvector n\'est pas installé !');
+      console.error('   Installez-le avec: CREATE EXTENSION vector;');
+      throw new Error('pgvector extension not found');
+    }
+
+    console.log('✅ Extension pgvector trouvée');
+  } catch (error) {
+    console.error('❌ Erreur vérification pgvector:', error.message);
+    throw error;
+  }
+}
+
+async function createDatabase(client) {
+  console.log(`🔍 Vérification base de données ${OVERMIND_DB_NAME}...`);
+
+  try {
+    // Vérifier si la DB existe déjà
+    const checkRes = await client.query(
+      'SELECT 1 FROM pg_database WHERE datname = $1',
+      [OVERMIND_DB_NAME]
+    );
+
+    if (checkRes.rows.length > 0) {
+      console.log(`ℹ️  Base de données ${OVERMIND_DB_NAME} existe déjà`);
+      return;
+    }
+
+    // Créer la DB
+    console.log(`🏗️  Création base de données ${OVERMIND_DB_NAME}...`);
+    await client.query(`CREATE DATABASE "${OVERMIND_DB_NAME}"`);
+    console.log(`✅ Base de données ${OVERMIND_DB_NAME} créée`);
+
+  } catch (error) {
+    if (error.code === '42P04') {
+      // Duplicate database - c'est ok
+      console.log(`ℹ️  Base de données ${OVERMIND_DB_NAME} existe déjà`);
+      return;
+    }
+    console.error('❌ Erreur création DB:', error.message);
+    throw error;
+  }
+}
+
+async function initializeOvermindDb() {
+  console.log(`🔍 Initialisation base de données ${OVERMIND_DB_NAME}...`);
+
+  const client = new Client({
+    ...DB_CONFIG,
+    database: OVERMIND_DB_NAME,
+  });
+
+  try {
+    await client.connect();
+    console.log(`✅ Connecté à ${OVERMIND_DB_NAME}`);
+
+    // Activer pgvector
+    console.log('🔧 Activation extension pgvector...');
+    await client.query('CREATE EXTENSION IF NOT EXISTS vector');
+    console.log('✅ Extension pgvector activée');
+
+    // Créer les tables (via init-db.sql)
+    const initSqlPath = join(__dirname, '../init-db.sql');
+    try {
+      const initSql = readFileSync(initSqlPath, 'utf8');
+      console.log('🔧 Exécution init-db.sql...');
+      await client.query(initSql);
+      console.log('✅ Tables initialisées');
+    } catch (error) {
+      console.warn('⚠️  Erreur init-db.sql (peut-être déjà exécuté):', error.message);
+    }
+
+  } finally {
+    await client.end();
+    console.log(`✅ Déconnecté de ${OVERMIND_DB_NAME}`);
+  }
+}
+
+async function main() {
+  console.log('╔══════════════════════════════════════════════════════════════════╗');
+  console.log('║  SETUP OVERMIND DATABASE (PostgreSQL Existant)                   ║');
+  console.log('╚══════════════════════════════════════════════════════════════════╝');
+  console.log('');
+
+  const client = new Client(DB_CONFIG);
+
+  try {
+    // Se connecter à postgres
+    console.log('🔌 Connexion à PostgreSQL...');
+    await client.connect();
+    console.log(`✅ Connecté à PostgreSQL (${DB_CONFIG.host}:${DB_CONFIG.port})`);
+    console.log('');
+
+    // Étape 1: Vérifier pgvector
+    await checkPgVectorExtension(client);
+    console.log('');
+
+    // Étape 2: Créer la DB
+    await createDatabase(client);
+    console.log('');
+
+    // Fermer la connexion postgres
+    await client.end();
+
+    // Étape 3: Initialiser la DB OverMind
+    await initializeOvermindDb();
+
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════════════╗');
+    console.log('║  ✅ SETUP TERMINÉ AVEC SUCCÈS                                   ║');
+    console.log('║                                                                ║');
+    console.log('║  Prochaine étape:                                               ║');
+    console.log('║  1. docker-compose -f docker-compose.overmind.yml up -d      ║');
+    console.log('║  2. pnpm run build                                            ║');
+    console.log('║  3. pnpm run dev                                              ║');
+    console.log('╚══════════════════════════════════════════════════════════════════╝');
+
+  } catch (error) {
+    console.error('');
+    console.error('╔══════════════════════════════════════════════════════════════════╗');
+    console.error('║  ❌ ERREUR SETUP                                                  ║');
+    console.error('╚══════════════════════════════════════════════════════════════════╝');
+    console.error('');
+    console.error('Erreur:', error.message);
+
+    if (error.code === 'ECONNREFUSED') {
+      console.error('');
+      console.error('💡 Assurez-vous que PostgreSQL est démarré:');
+      console.error('   docker ps | grep postgres-pgvector');
+      console.error('');
+      console.error('💡 Vérifiez les credentials dans .env:');
+      console.error('   POSTGRES_HOST=' + DB_CONFIG.host);
+      console.error('   POSTGRES_PORT=' + DB_CONFIG.port);
+      console.error('   POSTGRES_USER=' + DB_CONFIG.user);
+      console.error('   POSTGRES_PASSWORD=*** (votre mot de passe)');
+    }
+
+    process.exit(1);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN
+// ═══════════════════════════════════════════════════════════════════════════════
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}

package/scripts/setup-windows.js

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+/**
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * SETUP WINDOWS SCRIPT
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * Script d'installation automatique pour OverMind-MCP sur Windows
+ * avec PostgreSQL + pgvector existant en Docker.
+ *
+ * Usage:
+ *   node scripts/setup-windows.js
+ * ═══════════════════════════════════════════════════════════════════════════════
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, readFileSync, writeFileSync, copyFileSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const projectRoot = join(__dirname, '..');
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILITIES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function runCommand(command, description) {
+  console.log(`\n🔧 ${description}`);
+  console.log(`   $ ${command}`);
+  try {
+    execSync(command, { cwd: projectRoot, stdio: 'inherit' });
+    console.log(`✅ ${description} terminé`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Erreur: ${error.message}`);
+    return false;
+  }
+}
+
+function logSection(title) {
+  console.log('\n╔══════════════════════════════════════════════════════════════════╗');
+  console.log(`║  ${title.padEnd(64)} ║`);
+  console.log('╚══════════════════════════════════════════════════════════════════╝');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CHECKS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function checkPrerequisites() {
+  logSection('VÉRIFICATION PRÉREQUIS');
+
+  // Check Node.js
+  try {
+    const nodeVersion = execSync('node --version', { encoding: 'utf8' }).trim();
+    console.log(`✅ Node.js: ${nodeVersion}`);
+  } catch {
+    console.error('❌ Node.js non trouvé. Installez Node.js 20+');
+    return false;
+  }
+
+  // Check pnpm
+  try {
+    const pnpmVersion = execSync('pnpm --version', { encoding: 'utf8' }).trim();
+    console.log(`✅ pnpm: ${pnpmVersion}`);
+  } catch {
+    console.error('❌ pnpm non trouvé. Installez pnpm:');
+    console.error('   npm install -g pnpm');
+    return false;
+  }
+
+  // Check Docker
+  try {
+    const dockerVersion = execSync('docker --version', { encoding: 'utf8' }).trim();
+    console.log(`✅ Docker: ${dockerVersion}`);
+  } catch {
+    console.error('❌ Docker non trouvé. Installez Docker Desktop:');
+    console.error('   https://www.docker.com/products/docker-desktop/');
+    return false;
+  }
+
+  // Check PostgreSQL container
+  try {
+    const pgContainers = execSync('docker ps --filter "name=postgres-pgvector" --format "{{.Names}}"', { encoding: 'utf8' }).trim();
+    if (pgContainers) {
+      console.log(`✅ PostgreSQL container: ${pgContainers}`);
+    } else {
+      console.error('❌ Container postgres-pgvector non trouvé');
+      console.error('   Assurez-vous que PostgreSQL + pgvector tourne en Docker');
+      return false;
+    }
+  } catch {
+    console.error('❌ Impossible de vérifier le container PostgreSQL');
+    return false;
+  }
+
+  return true;
+}
+
+function checkEnvFile() {
+  logSection('VÉRIFICATION FICHIER .ENV');
+
+  const envPath = join(projectRoot, '.env');
+  const envExamplePath = join(projectRoot, '.env.example');
+
+  if (!existsSync(envPath)) {
+    console.log('ℹ️  .env non trouvé, création à partir de .env.example...');
+    if (existsSync(envExamplePath)) {
+      copyFileSync(envExamplePath, envPath);
+      console.log('✅ .env créé');
+      console.warn('⚠️  ÉDITEZ .env et changez:');
+      console.warn('   - POSTGRES_PASSWORD=votre_mot_de_passe');
+      console.warn('   - OVERMIND_EMBEDDING_KEY=votre_cle_api');
+      return false; // Arrêt pour permettre l'édition
+    } else {
+      console.error('❌ .env.example non trouvé');
+      return false;
+    }
+  } else {
+    console.log('✅ .env existe');
+    return true;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SETUP STEPS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function setupDatabase() {
+  logSection('INITIALISATION BASE DE DONNÉES');
+
+  return runCommand(
+    'node scripts/setup-overmind-db.js',
+    'Initialisation base OverMind'
+  );
+}
+
+function startDockerServices() {
+  logSection('DÉMARRAGE SERVICES DOCKER');
+
+  return runCommand(
+    'docker-compose -f docker-compose.overmind.yml up -d',
+    'Démarrage RabbitMQ + Temporal'
+  );
+}
+
+function buildProject() {
+  logSection('BUILD PROJET');
+
+  return runCommand(
+    'pnpm run build',
+    'Compilation TypeScript'
+  );
+}
+
+function runTests() {
+  logSection('TESTS UNITAIRES');
+
+  return runCommand(
+    'pnpm run test -- --run',
+    'Exécution tests'
+  );
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function main() {
+  console.log('╔══════════════════════════════════════════════════════════════════╗');
+  console.log('║                                                                ║');
+  console.log('║         OVERMIND-MCP: SETUP WINDOWS AUTOMATISÉ                    ║');
+  console.log('║         (PostgreSQL Existant + Docker)                             ║');
+  console.log('║                                                                ║');
+  console.log('╚══════════════════════════════════════════════════════════════════╝');
+  console.log('');
+
+  // Check prerequisites
+  if (!checkPrerequisites()) {
+    console.log('\n❌ PRÉREQUIS NON REMPLIS. Corrigez les problèmes ci-dessus et relancez.');
+    process.exit(1);
+  }
+
+  // Check .env file
+  const envReady = checkEnvFile();
+  if (!envReady) {
+    console.log('\n⏸️  SETUP EN PAUSE. Éditez .env avec vos credentials, puis relancez.');
+    console.log('\n   Commande pour relancer:');
+    console.log('   node scripts/setup-windows.js');
+    process.exit(0);
+  }
+
+  // Setup database
+  const dbSetup = await setupDatabase();
+  if (!dbSetup) {
+    console.log('\n❌ ERREUR INITIALISATION BASE DE DONNÉES');
+    process.exit(1);
+  }
+
+  // Start Docker services
+  const dockerStarted = startDockerServices();
+  if (!dockerStarted) {
+    console.log('\n❌ ERREUR DÉMARRAGE SERVICES DOCKER');
+    process.exit(1);
+  }
+
+  // Build project
+  const projectBuilt = buildProject();
+  if (!projectBuilt) {
+    console.log('\n❌ ERREUR BUILD PROJET');
+    process.exit(1);
+  }
+
+  // Run tests
+  runTests();
+
+  // Success!
+  logSection('✅ SETUP TERMINÉ AVEC SUCCÈS');
+
+  console.log(`
+🎉 OVERMIND-MCP EST PRÊT !
+
+📋 SERVICES DÉMARRÉS:
+   ✅ PostgreSQL (votre container existant)
+   ✅ RabbitMQ (Message Broker)
+   ✅ Temporal (Workflow Orchestrator)
+   ✅ OverMind Agents (prêt à démarrer)
+
+🌐 INTERFACES DISPONIBLES:
+   📊 RabbitMQ:     http://localhost:15672
+   📈 Temporal:      http://localhost:8088
+   🗄️  PostgreSQL:    localhost:5432
+
+🚀 POUR DÉMARRER OVERMIND:
+   pnpm run dev      # Mode développement
+   pnpm run start    # Mode production
+
+📚 DOCUMENTATION:
+   - SETUP_WINDOWS.md (guide complet)
+   - DEPLOYMENT.md (déploiement avancé)
+   - SWARM_USAGE.md (utilisation Swarm)
+
+💡 PREMIER TEST:
+   create_agent({
+     name: 'test-agent',
+     prompt: 'Tu es un agent de test',
+     runner: 'claude'
+   })
+
+═════════════════════════════════════════════════════════════════════
+`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ENTRY POINT
+// ═══════════════════════════════════════════════════════════════════════════════
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error('\n❌ ERREUR FATALE:', error.message);
+    process.exit(1);
+  });
+}