overmind-mcp 2.0.0 → 2.0.1

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);
+  });
+}

package/scripts/setup.mjs

@@ -0,0 +1,396 @@
+#!/usr/bin/env node
+/**
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * SETUP SCRIPT - Installation Automatique OverMind
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * Script principal qui installe TOUTES les dépendances nécessaires à OverMind:
+ * - Docker (si pas présent)
+ * - PostgreSQL + pgvector (si pas présent)
+ * - RabbitMQ
+ * - Temporal
+ * - Configuration automatique
+ *
+ * Usage:
+ *   overmind-setup [--full]
+ * ═══════════════════════════════════════════════════════════════════════════════
+ */
+
+import { execSync, spawn } from 'child_process';
+import { copyFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { createInterface } from 'readline';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const projectRoot = join(__dirname, '..');
+const INSTALL_DIR = join(process.env.HOME || process.env.USERPROFILE || process.env.HOMEPATH, '.overmind');
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function logSection(title) {
+  console.log('\n╔══════════════════════════════════════════════════════════════════╗');
+  console.log(`║  ${title.padEnd(64)} ║`);
+  console.log('╚══════════════════════════════════════════════════════════════════╝');
+}
+
+function runCommand(cmd, description) {
+  console.log(`\n🔧 ${description}`);
+  console.log(`   $ ${cmd}`);
+  try {
+    execSync(cmd, { stdio: 'inherit' });
+    console.log(`✅ ${description} terminé`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Erreur: ${error.message}`);
+    return false;
+  }
+}
+
+function runCommandAsync(cmd, description) {
+  return new Promise((resolve, reject) => {
+    console.log(`\n🔧 ${description}`);
+    console.log(`   $ ${cmd}`);
+    const child = spawn(cmd, { shell: true, stdio: 'inherit' });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        console.log(`✅ ${description} terminé`);
+        resolve(true);
+      } else {
+        console.error(`❌ Erreur (code ${code})`);
+        reject(new Error(`Command failed with code ${code}`));
+      }
+    });
+
+    child.on('error', (err) => {
+      console.error('❌ Erreur:', err.message);
+      reject(err);
+    });
+  });
+}
+
+async function promptYesNo(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const answer = await new Promise((resolve) => {
+    rl.question(`${question} (y/N): `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith('y'));
+    });
+  });
+
+  return answer;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CHECKS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function checkDocker() {
+  try {
+    execSync('docker --version', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function checkPostgreSQL() {
+  try {
+    execSync('docker ps --filter "name=postgres" --format "{{.Names}}"', { stdio: 'pipe' });
+    return true;
+  } catch {
+    try {
+      execSync('psql --version', { stdio: 'pipe' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// INSTALLATION STEPS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function installDocker() {
+  logSection('INSTALLATION DOCKER');
+
+  if (checkDocker()) {
+    console.log('✅ Docker est déjà installé');
+    return true;
+  }
+
+  console.log('ℹ️  Docker non trouvé.');
+  console.log('');
+  console.log('📥 Docker Desktop est requis pour OverMind-MCP:');
+  console.log('   - Windows: https://www.docker.com/products/docker-desktop/');
+  console.log('   - Mac: https://www.docker.com/products/docker-desktop/');
+  console.log('');
+  console.log('📋 Instructions:');
+  console.log('   1. Téléchargez et installez Docker Desktop');
+  console.log('   2. Démarrez Docker Desktop');
+  console.log('   3. Relancez: overmind-setup --full');
+  console.log('');
+
+  const answer = await promptYesNo('Voulez-vous ouvrir le site de téléchargement maintenant ?');
+  if (answer) {
+    const url = process.platform === 'win32'
+      ? 'https://www.docker.com/products/docker-desktop/'
+      : 'https://www.docker.com/products/docker-desktop/';
+
+    try {
+      execSync(`start ${url}`, { stdio: 'inherit' });
+      console.log('✅ Navigateur ouvert. Attendez l\'installation de Docker.');
+    } catch {
+      console.log('⚠️  Impossible d\'ouvrir le navigateur automatiquement.');
+      console.log(`   Ouvrez manuellement: ${url}`);
+    }
+  }
+
+  return false;
+}
+
+async function installPostgreSQL() {
+  logSection('INSTALLATION POSTGRESQL + PGVECTOR');
+
+  if (checkPostgreSQL()) {
+    console.log('✅ PostgreSQL est déjà installé');
+    return true;
+  }
+
+  console.log('🐳 Installation PostgreSQL + pgvector en Docker...');
+  console.log('');
+
+  try {
+    // Pull and start PostgreSQL container
+    console.log('📥 Téléchargement image pgvector/pgvector:pg16...');
+    execSync('docker pull pgvector/pgvector:pg16', { stdio: 'inherit' });
+
+    console.log('🚀 Démarrage container PostgreSQL...');
+    const runCommand = `docker run -d --name postgres-pgvector \\
+      -p 5432:5432 \\
+      -e POSTGRES_PASSWORD=overmind_temp_password_change_me \\
+      -e POSTGRES_USER=postgres \\
+      -v postgres_data:/var/lib/postgresql/data \\
+      --restart unless-stopped \\
+      pgvector/pgvector:pg16`;
+
+    await runCommandAsync(runCommand, 'Démarrage PostgreSQL');
+
+    // Wait for PostgreSQL to be ready
+    console.log('⏳ Attente démarrage PostgreSQL (30s)...');
+    await new Promise((resolve) => setTimeout(resolve, 30000));
+
+    // Verify pgvector
+    console.log('🔍 Vérification pgvector...');
+    await runCommandAsync(
+      'docker exec postgres-pgvector psql -U postgres -c "CREATE EXTENSION IF NOT EXISTS vector;"',
+      'Activation pgvector'
+    );
+
+    console.log('✅ PostgreSQL + pgvector installés avec succès !');
+    return true;
+
+  } catch (error) {
+    console.error('❌ Erreur installation PostgreSQL:', error.message);
+    return false;
+  }
+}
+
+function setupConfigurationFiles() {
+  logSection('CONFIGURATION OVERMIND');
+
+  // Create install directory
+  if (!existsSync(INSTALL_DIR)) {
+    mkdirSync(INSTALL_DIR, { recursive: true });
+    console.log('✅ Dossier créé:', INSTALL_DIR);
+  }
+
+  // Copy docker-compose file
+  const dockerComposePath = join(projectRoot, 'docker-compose.overmind.yml');
+  const destComposePath = join(INSTALL_DIR, 'docker-compose.overmind.yml');
+
+  if (existsSync(dockerComposePath)) {
+    copyFileSync(dockerComposePath, destComposePath);
+    console.log('✅ docker-compose.overmind.yml copié');
+  }
+
+  // Copy .env.example if .env doesn't exist
+  const envExamplePath = join(projectRoot, '.env.example');
+  const envPath = join(INSTALL_DIR, '.env');
+
+  if (!existsSync(envPath) && existsSync(envExamplePath)) {
+    copyFileSync(envExamplePath, envPath);
+    console.log('✅ .env créé (à éditer avec vos credentials)');
+  }
+
+  // Copy docker-manager script
+  const dockerManagerPath = join(__dirname, 'docker-manager.js');
+  const destManagerPath = join(INSTALL_DIR, 'docker-manager.js');
+
+  copyFileSync(dockerManagerPath, destManagerPath);
+  console.log('✅ Scripts Docker installés');
+
+  return true;
+}
+
+async function startDockerServices() {
+  logSection('DÉMARRAGE SERVICES DOCKER');
+
+  const composeFile = join(INSTALL_DIR, 'docker-compose.overmind.yml');
+
+  console.log('🚀 Démarrage RabbitMQ + Temporal...');
+  try {
+    await runCommandAsync(
+      `docker-compose -f "${composeFile}" up -d`,
+      'Démarrage services'
+    );
+    console.log('✅ Services Docker démarrés');
+    console.log('');
+    console.log('🌐 Interfaces disponibles:');
+    console.log('   📊 RabbitMQ: http://localhost:15672');
+    console.log('   📈 Temporal:  http://localhost:8088');
+    return true;
+  } catch (error) {
+    console.error('❌ Erreur démarrage Docker:', error.message);
+    return false;
+  }
+}
+
+async function createOvermindDatabase() {
+  logSection('CRÉATION BASE OVERMIND');
+
+  // Import and run setup-overmind-db.js
+  const setupDbPath = join(__dirname, 'setup-overmind-db.js');
+
+  try {
+    // Copy script to install dir
+    const destDbPath = join(INSTALL_DIR, 'setup-overmind-db.js');
+    copyFileSync(setupDbPath, destDbPath);
+
+    // Run it
+    await runCommandAsync(
+      `node "${destDbPath}"`,
+      'Initialisation DB OverMind'
+    );
+    return true;
+  } catch (error) {
+    console.error('❌ Erreur création DB:', error.message);
+    return false;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function main() {
+  const args = process.argv.slice(2);
+  const isFull = args.includes('--full');
+
+  console.log('╔══════════════════════════════════════════════════════════════════╗');
+  console.log('║                                                                ║');
+  console.log('║     🧠 OVERMIND-MCP: SETUP AUTOMATISÉ COMPLET                   ║');
+  console.log('║                                                                ║');
+  console.log('╚══════════════════════════════════════════════════════════════════╝');
+  console.log('');
+
+  if (!isFull) {
+    console.log('ℹ️  USAGE: overmind-setup [--full]');
+    console.log('');
+    console.log('   --full: Installe TOUTES les dépendances (Docker, PostgreSQL, etc.)');
+    console.log('           et configure OverMind automatiquement');
+    console.log('');
+    console.log('   Sans --full: Prépare juste les fichiers de configuration');
+    console.log('');
+
+    return;
+  }
+
+  // Step 1: Check Docker
+  const hasDocker = checkDocker();
+  if (!hasDocker) {
+    const installed = await installDocker();
+    if (!installed) {
+      console.log('\n❌ SETUP ANNULÉ - Docker est requis pour le mode complet');
+      console.log('   Installez Docker Desktop et relancez: overmind-setup --full');
+      process.exit(1);
+    }
+  }
+
+  // Step 2: Check PostgreSQL
+  const hasPostgreSQL = checkPostgreSQL();
+  if (!hasPostgreSQL) {
+    const installed = await installPostgreSQL();
+    if (!installed) {
+      console.log('\n❌ SETUP ANNULÉ - PostgreSQL est requis pour le mode complet');
+      process.exit(1);
+    }
+  }
+
+  // Step 3: Setup configuration files
+  setupConfigurationFiles();
+
+  // Step 4: Start Docker services
+  const servicesStarted = await startDockerServices();
+  if (!servicesStarted) {
+    console.log('\n❌ SETUP ANNULÉ - Impossible de démarrer les services');
+    process.exit(1);
+  }
+
+  // Step 5: Create OverMind database
+  const dbCreated = await createOvermindDatabase();
+  if (!dbCreated) {
+    console.log('\n❌ SETUP ANNULÉ - Impossible de créer la base OverMind');
+    process.exit(1);
+  }
+
+  // Success!
+  logSection('✅ SETUP COMPLET TERMINÉ AVEC SUCCÈS');
+
+  console.log(`
+🎉 OVERMIND-MCP EST PRÊT !
+
+📋 SERVICES ACTIFS:
+   ✅ PostgreSQL + pgvector (Vector DB 4096D)
+   ✅ RabbitMQ (Message Broker)
+   ✅ Temporal (Workflow Orchestrator)
+   ✅ OverMind Agents (prêt à l'emploi)
+
+🌐 INTERFACES:
+   📊 RabbitMQ Management: http://localhost:15672
+   📈 Temporal Web:       http://localhost:8088
+   🗄️  PostgreSQL:         localhost:5432
+
+🚀 COMMANDES DISPONIBLES:
+   overmind create-agent --name expert --runner claude
+   overmind run-agent --runner claude --prompt "Analyse..."
+   overmind-infra up/down/status/logs
+
+📚 DOCUMENTATION:
+   - https://deamondev888.github.io/overmind-mcp/
+   - https://github.com/DeamonDev888/overmind-mcp
+   - Discord: https://discord.gg/4AR82phtBz
+
+💡 PREMIER TEST:
+   overmind create-agent --name test --runner claude --prompt "Test d'OverMind"
+
+═══════════════════════════════════════════════════════════════════════
+`);
+}
+
+// Run main
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error('\n❌ ERREUR FATALE:', error.message);
+    process.exit(1);
+  });
+}