@supersoniks/concorde 3.2.0 → 3.2.1

package/mcp-server/concorde-mcp-server.js

@@ -0,0 +1,859 @@
+#!/usr/bin/env node
+
+/**
+ * Serveur MCP pour Concorde - Framework de composants Web
+ * Version Node.js
+ * Permet à l'IA de Cursor d'accéder facilement à toute la documentation et au code de Concorde
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+// Configuration du projet Concorde
+const CONCORDE_ROOT = path.dirname(path.dirname(new URL(import.meta.url).pathname));
+const SRC_PATH = path.join(CONCORDE_ROOT, 'src');
+const DOCS_PATH = path.join(CONCORDE_ROOT, 'docs');
+const CORE_PATH = path.join(SRC_PATH, 'core');
+const COMPONENTS_PATH = path.join(CORE_PATH, 'components');
+
+class ComponentInfo {
+  constructor(name, tagName, category, filePath, docPath, description, props, examples) {
+    this.name = name;
+    this.tagName = tagName;
+    this.category = category;
+    this.filePath = filePath;
+    this.docPath = docPath;
+    this.description = description;
+    this.props = props;
+    this.examples = examples;
+  }
+}
+
+class ConcordeMCPServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'concorde-mcp',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          resources: {},
+          tools: {},
+        },
+      }
+    );
+
+    this.components = new Map();
+    this.documentation = new Map();
+
+    this.setupHandlers();
+  }
+
+  async initialize() {
+    await this.loadComponents();
+    await this.loadDocumentation();
+  }
+
+  setupHandlers() {
+    // Handler pour lister les ressources
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      const resources = [];
+
+      // Ressources de composants
+      for (const [compName, compInfo] of this.components) {
+        resources.push({
+          uri: `concorde://component/${compName}`,
+          name: `Composant ${compName}`,
+          description: compInfo.description,
+          mimeType: 'text/markdown'
+        });
+      }
+
+      // Ressources de documentation
+      for (const [docName, docContent] of this.documentation) {
+        resources.push({
+          uri: `concorde://docs/${docName}`,
+          name: `Documentation ${docName}`,
+          description: `Documentation Concorde: ${docName}`,
+          mimeType: 'text/markdown'
+        });
+      }
+
+      // Ressources d'exemples
+      resources.push({
+        uri: 'concorde://examples/ui-components',
+        name: 'Exemples composants UI',
+        description: 'Exemples d\'utilisation des composants UI',
+        mimeType: 'text/markdown'
+      });
+
+      resources.push({
+        uri: 'concorde://examples/functional-components',
+        name: 'Exemples composants fonctionnels',
+        description: 'Exemples d\'utilisation des composants fonctionnels',
+        mimeType: 'text/markdown'
+      });
+
+      return { resources };
+    });
+
+    // Handler pour lire les ressources
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const { uri } = request.params;
+
+      if (uri.startsWith('concorde://component/')) {
+        const compName = uri.replace('concorde://component/', '');
+        if (this.components.has(compName)) {
+          const compInfo = this.components.get(compName);
+          const content = this.generateComponentDoc(compInfo);
+          return {
+            contents: [{
+              type: 'text',
+              text: content
+            }]
+          };
+        }
+      }
+
+      if (uri.startsWith('concorde://docs/')) {
+        const docName = uri.replace('concorde://docs/', '');
+        if (this.documentation.has(docName)) {
+          return {
+            contents: [{
+              type: 'text',
+              text: this.documentation.get(docName)
+            }]
+          };
+        }
+      }
+
+      if (uri === 'concorde://examples/ui-components') {
+        const content = this.generateUIExamples();
+        return {
+          contents: [{
+            type: 'text',
+            text: content
+          }]
+        };
+      }
+
+      if (uri === 'concorde://examples/functional-components') {
+        const content = this.generateFunctionalExamples();
+        return {
+          contents: [{
+            type: 'text',
+            text: content
+          }]
+        };
+      }
+
+      return {
+        contents: [{
+          type: 'text',
+          text: 'Ressource non trouvée'
+        }]
+      };
+    });
+
+    // Handler pour lister les outils
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      const tools = [
+        {
+          name: 'search_component',
+          description: 'Recherche un composant Concorde par nom ou fonctionnalité',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              query: {
+                type: 'string',
+                description: 'Terme de recherche (nom du composant, fonctionnalité, etc.)'
+              }
+            },
+            required: ['query']
+          }
+        },
+        {
+          name: 'get_component_info',
+          description: 'Obtient des informations détaillées sur un composant spécifique',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              component_name: {
+                type: 'string',
+                description: 'Nom du composant (ex: button, modal, input)'
+              }
+            },
+            required: ['component_name']
+          }
+        },
+        {
+          name: 'generate_component_code',
+          description: 'Génère du code HTML pour un composant Concorde avec ses propriétés',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              component_name: {
+                type: 'string',
+                description: 'Nom du composant'
+              },
+              properties: {
+                type: 'object',
+                description: 'Propriétés du composant',
+                additionalProperties: true
+              },
+              content: {
+                type: 'string',
+                description: 'Contenu du composant (optionnel)'
+              }
+            },
+            required: ['component_name']
+          }
+        },
+        {
+          name: 'get_form_example',
+          description: 'Génère un exemple de formulaire avec des composants Concorde',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              fields: {
+                type: 'array',
+                description: 'Liste des champs du formulaire',
+                items: {
+                  type: 'object',
+                  properties: {
+                    name: { type: 'string' },
+                    type: { type: 'string' },
+                    label: { type: 'string' },
+                    required: { type: 'boolean' }
+                  }
+                }
+              }
+            }
+          }
+        },
+        {
+          name: 'get_theme_info',
+          description: 'Obtient des informations sur le système de thèmes Concorde',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              theme: {
+                type: 'string',
+                description: 'Nom du thème (light, dark, auto)',
+                enum: ['light', 'dark', 'auto']
+              }
+            }
+          }
+        },
+        {
+          name: 'get_icons_list',
+          description: 'Liste toutes les icônes disponibles dans Concorde',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              library: {
+                type: 'string',
+                description: 'Bibliothèque d\'icônes (core, iconoir, fontAwesome)',
+                enum: ['core', 'iconoir', 'fontAwesome']
+              }
+            }
+          }
+        }
+      ];
+
+      return { tools };
+    });
+
+    // Handler pour exécuter les outils
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      switch (name) {
+        case 'search_component':
+          return await this.searchComponent(args.query);
+        case 'get_component_info':
+          return await this.getComponentInfo(args.component_name);
+        case 'generate_component_code':
+          return await this.generateComponentCode(
+            args.component_name,
+            args.properties || {},
+            args.content || ''
+          );
+        case 'get_form_example':
+          return await this.getFormExample(args.fields || []);
+        case 'get_theme_info':
+          return await this.getThemeInfo(args.theme || 'light');
+        case 'get_icons_list':
+          return await this.getIconsList(args.library || 'core');
+        default:
+          return {
+            content: [{
+              type: 'text',
+              text: `Outil inconnu: ${name}`
+            }]
+          };
+      }
+    });
+  }
+
+  async loadComponents() {
+    // Charger les composants UI
+    const uiPath = path.join(COMPONENTS_PATH, 'ui');
+    await this.loadComponentsFromDirectory(uiPath, 'ui');
+
+    // Charger les composants fonctionnels
+    const functionalPath = path.join(COMPONENTS_PATH, 'functional');
+    await this.loadComponentsFromDirectory(functionalPath, 'functional');
+  }
+
+  async loadComponentsFromDirectory(dirPath, category) {
+    try {
+      const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith('_')) {
+          await this.loadComponent(path.join(dirPath, entry.name), category);
+        }
+      }
+    } catch (error) {
+      console.warn(`Impossible de lire le répertoire ${dirPath}:`, error.message);
+    }
+  }
+
+  async loadComponent(compDir, category) {
+    const compName = path.basename(compDir);
+    const tagName = `sonic-${compName}`;
+
+    // Trouve le fichier principal
+    const mainFile = path.join(compDir, `${compName}.ts`);
+
+    try {
+      const content = await fs.readFile(mainFile, 'utf-8');
+
+      // Trouve le fichier de documentation
+      const docFile = path.join(compDir, `${compName}.md`);
+      let docContent = '';
+      try {
+        docContent = await fs.readFile(docFile, 'utf-8');
+      } catch {
+        // Pas de documentation
+      }
+
+      // Extrait les propriétés du composant
+      const props = this.extractProperties(content);
+
+      // Extrait la description
+      const description = this.extractDescription(content);
+
+      // Extrait les exemples de la documentation
+      const examples = this.extractExamples(docContent);
+
+      const compInfo = new ComponentInfo(
+        compName,
+        tagName,
+        category,
+        mainFile,
+        docFile,
+        description,
+        props,
+        examples
+      );
+
+      this.components.set(compName, compInfo);
+    } catch (error) {
+      console.warn(`Impossible de charger le composant ${compName}:`, error.message);
+    }
+  }
+
+  extractProperties(content) {
+    const props = [];
+
+    // Recherche les décorateurs @property
+    const propertyPattern = /@property\([^)]*\)\s+(\w+)(?::\s*([^=]+))?/g;
+    let match;
+
+    while ((match = propertyPattern.exec(content)) !== null) {
+      const propName = match[1];
+      const propType = match[2] ? match[2].trim() : 'string';
+
+      // Recherche les commentaires JSDoc pour cette propriété
+      const commentPattern = new RegExp(`/\\*\\*\\s*\\n\\s*\\*\\s*([^\\n]+)`, 'g');
+      const commentMatch = commentPattern.exec(content);
+      const description = commentMatch ? commentMatch[1].trim() : '';
+
+      props.push({
+        name: propName,
+        type: propType,
+        description: description
+      });
+    }
+
+    return props;
+  }
+
+  extractDescription(content) {
+    // Recherche les commentaires de classe
+    const classPattern = /\/\*\*\s*\n\s*\*\s*([^\n]+)/;
+    const match = classPattern.exec(content);
+    if (match) {
+      return match[1].trim();
+    }
+
+    // Recherche le nom de la classe
+    const classNamePattern = /export class (\w+)/;
+    const classNameMatch = classNamePattern.exec(content);
+    if (classNameMatch) {
+      return `Composant ${classNameMatch[1]}`;
+    }
+
+    return 'Composant Concorde';
+  }
+
+  extractExamples(docContent) {
+    const examples = [];
+
+    // Recherche les blocs sonic-code
+    const codePattern = /<sonic-code>(.*?)<\/sonic-code>/gs;
+    let match;
+
+    while ((match = codePattern.exec(docContent)) !== null) {
+      const example = match[1].trim();
+      if (example) {
+        examples.push(example);
+      }
+    }
+
+    return examples;
+  }
+
+  async loadDocumentation() {
+    // Documentation des concepts de base
+    this.documentation.set('architecture', `
+# Architecture Concorde
+
+Concorde est un framework de composants Web basé sur Lit Element avec les concepts suivants :
+
+## Mixins principaux
+
+### Subscriber
+- Permet de lier un composant à un publisher
+- Gestion automatique des données réactives
+- Support du data binding
+
+### FormElement
+- Gestion des formulaires
+- Validation automatique
+- Liaison avec les publishers de formulaire
+
+### Fetcher
+- Gestion des appels API
+- Chargement automatique des données
+- Support des filtres et pagination
+
+## Système de thèmes
+- Thèmes light/dark/auto
+- Variables CSS personnalisables
+- Support des couleurs sémantiques
+
+## Composants disponibles
+- Composants UI : boutons, inputs, modales, etc.
+- Composants fonctionnels : fetch, list, router, etc.
+- Système d'icônes intégré
+`);
+
+    this.documentation.set('data-binding', `
+# Data Binding Concorde
+
+## Syntaxe
+- \`data-bind ::attribute="expression"\` : Liaison d'attribut
+- \`data-bind ::inner-html="expression"\` : Liaison de contenu HTML
+- \`data-bind ::text-content="expression"\` : Liaison de contenu texte
+
+## Expressions
+- \`$property\` : Accès à une propriété du publisher
+- \`$property.subproperty\` : Accès à une sous-propriété
+- \`function|$property\` : Application d'une fonction
+
+## Exemples
+\`\`\`html
+<sonic-input data-bind ::value="$email"></sonic-input>
+<span data-bind ::inner-html="$name"></span>
+<div data-bind ::class="active|$isActive"></div>
+\`\`\`
+`);
+  }
+
+  async searchComponent(query) {
+    const results = [];
+    const queryLower = query.toLowerCase();
+
+    for (const [compName, compInfo] of this.components) {
+      if (compName.toLowerCase().includes(queryLower) ||
+        compInfo.description.toLowerCase().includes(queryLower) ||
+        compInfo.tagName.toLowerCase().includes(queryLower)) {
+        results.push(`- **${compInfo.tagName}** (${compInfo.category}): ${compInfo.description}`);
+      }
+    }
+
+    const content = results.length > 0
+      ? `Composants trouvés pour '${query}':\n\n${results.join('\n')}`
+      : `Aucun composant trouvé pour '${query}'`;
+
+    return {
+      content: [{
+        type: 'text',
+        text: content
+      }]
+    };
+  }
+
+  async getComponentInfo(componentName) {
+    if (!this.components.has(componentName)) {
+      return {
+        content: [{
+          type: 'text',
+          text: `Composant '${componentName}' non trouvé`
+        }]
+      };
+    }
+
+    const compInfo = this.components.get(componentName);
+    const content = this.generateComponentDoc(compInfo);
+
+    return {
+      content: [{
+        type: 'text',
+        text: content
+      }]
+    };
+  }
+
+  async generateComponentCode(componentName, properties, content = '') {
+    if (!this.components.has(componentName)) {
+      return {
+        content: [{
+          type: 'text',
+          text: `Composant '${componentName}' non trouvé`
+        }]
+      };
+    }
+
+    const compInfo = this.components.get(componentName);
+    const tagName = compInfo.tagName;
+
+    // Génère les attributs
+    const attributes = [];
+    for (const [key, value] of Object.entries(properties)) {
+      if (typeof value === 'boolean') {
+        if (value) {
+          attributes.push(key);
+        }
+      } else {
+        attributes.push(`${key}="${value}"`);
+      }
+    }
+
+    // Génère le code HTML
+    const htmlCode = content
+      ? `<${tagName} ${attributes.join(' ')}>${content}</${tagName}>`
+      : `<${tagName} ${attributes.join(' ')}></${tagName}>`;
+
+    return {
+      content: [{
+        type: 'text',
+        text: htmlCode
+      }]
+    };
+  }
+
+  async getFormExample(fields) {
+    if (fields.length === 0) {
+      // Exemple par défaut
+      fields = [
+        { name: 'email', type: 'email', label: 'Email', required: true },
+        { name: 'password', type: 'password', label: 'Mot de passe', required: true },
+        { name: 'remember', type: 'checkbox', label: 'Se souvenir de moi', required: false }
+      ];
+    }
+
+    let formHtml = '<div formDataProvider="exampleForm">\n';
+
+    for (const field of fields) {
+      const { name, type, label, required } = field;
+
+      if (type === 'checkbox') {
+        formHtml += `  <sonic-checkbox name="${name}"`;
+        if (required) {
+          formHtml += ' required';
+        }
+        formHtml += `>${label}</sonic-checkbox>\n`;
+      } else {
+        formHtml += `  <sonic-input name="${name}" type="${type}" label="${label}"`;
+        if (required) {
+          formHtml += ' required';
+        }
+        formHtml += '></sonic-input>\n';
+      }
+    }
+
+    formHtml += '  <sonic-form-actions>\n';
+    formHtml += '    <sonic-button type="primary">Valider</sonic-button>\n';
+    formHtml += '    <sonic-button variant="outline">Annuler</sonic-button>\n';
+    formHtml += '  </sonic-form-actions>\n';
+    formHtml += '</div>';
+
+    return {
+      content: [{
+        type: 'text',
+        text: formHtml
+      }]
+    };
+  }
+
+  async getThemeInfo(theme) {
+    const themeInfo = {
+      light: {
+        description: 'Thème clair par défaut',
+        colors: {
+          primary: '#1e293b',
+          info: '#2563eb',
+          danger: '#f43f5e',
+          warning: '#f97316',
+          success: '#14b8a6'
+        }
+      },
+      dark: {
+        description: 'Thème sombre',
+        colors: {
+          primary: '#334155',
+          info: '#3abff8',
+          danger: '#f87272',
+          warning: '#fbbd23',
+          success: '#36d399'
+        }
+      },
+      auto: {
+        description: 'Thème automatique basé sur les préférences système',
+        colors: 'Utilise les couleurs du thème sombre si l\'utilisateur préfère le mode sombre'
+      }
+    };
+
+    const info = themeInfo[theme] || themeInfo.light;
+
+    let content = `# Thème ${theme}\n\n${info.description}\n\n## Utilisation\n\n\`\`\`html\n<sonic-theme theme="${theme}">\n  <!-- Vos composants ici -->\n</sonic-theme>\n\`\`\`\n\n`;
+
+    if (info.colors && typeof info.colors === 'object') {
+      content += '## Couleurs\n\n';
+      for (const [colorName, colorValue] of Object.entries(info.colors)) {
+        content += `- **${colorName}**: \`${colorValue}\`\n`;
+      }
+    }
+
+    return {
+      content: [{
+        type: 'text',
+        text: content
+      }]
+    };
+  }
+
+  async getIconsList(library) {
+    const iconsInfo = {
+      core: [
+        'cancel', 'check-circled-outline', 'check', 'emoji-puzzled',
+        'info-empty', 'loader', 'minus-small', 'more-horiz', 'more-vert',
+        'nav-arrow-down', 'warning-circled-outline'
+      ],
+      iconoir: 'Bibliothèque d\'icônes externe avec de nombreuses icônes',
+      fontAwesome: 'Bibliothèque FontAwesome avec icônes solid et regular'
+    };
+
+    let content;
+
+    if (library === 'core') {
+      const icons = iconsInfo.core;
+      content = `# Icônes Core Concorde\n\n## Utilisation\n\n\`\`\`html\n<sonic-icon library="core" name="nom-de-l-icone"></sonic-icon>\n\`\`\`\n\n## Icônes disponibles\n\n`;
+      for (const icon of icons) {
+        content += `- **${icon}**: \`<sonic-icon library="core" name="${icon}"></sonic-icon>\`\n`;
+      }
+    } else {
+      content = `# Bibliothèque d'icônes ${library}\n\n${iconsInfo[library]}\n\n## Utilisation\n\n\`\`\`html\n<sonic-icon library="${library}" name="nom-de-l-icone"></sonic-icon>\n\`\`\`\n\nPour les icônes FontAwesome, vous pouvez spécifier le préfixe :\n\`\`\`html\n<sonic-icon library="fontAwesome" prefix="solid" name="home"></sonic-icon>\n<sonic-icon library="fontAwesome" prefix="regular" name="user"></sonic-icon>\n\`\`\`\n`;
+    }
+
+    return {
+      content: [{
+        type: 'text',
+        text: content
+      }]
+    };
+  }
+
+  generateComponentDoc(compInfo) {
+    let content = `# ${compInfo.tagName}\n\n**Catégorie:** ${compInfo.category}\n**Description:** ${compInfo.description}\n\n## Propriétés\n\n`;
+
+    for (const prop of compInfo.props) {
+      content += `- **${prop.name}** (${prop.type}): ${prop.description}\n`;
+    }
+
+    if (compInfo.examples.length > 0) {
+      content += '\n## Exemples\n\n';
+      for (let i = 0; i < Math.min(compInfo.examples.length, 3); i++) {
+        content += `### Exemple ${i + 1}\n\n\`\`\`html\n${compInfo.examples[i]}\n\`\`\`\n\n`;
+      }
+    }
+
+    return content;
+  }
+
+  generateUIExamples() {
+    return `# Exemples de composants UI Concorde
+
+## Bouton avec icône
+
+\`\`\`html
+<sonic-button type="primary">
+  <sonic-icon library="core" name="check" slot="prefix"></sonic-icon>
+  Valider
+</sonic-button>
+\`\`\`
+
+## Formulaire complet
+
+\`\`\`html
+<div formDataProvider="userForm">
+  <sonic-fieldset label="Informations utilisateur">
+    <sonic-form-layout>
+      <sonic-input name="firstName" label="Prénom" required></sonic-input>
+      <sonic-input name="lastName" label="Nom" required></sonic-input>
+      <sonic-input name="email" type="email" label="Email" required></sonic-input>
+    </sonic-form-layout>
+  </sonic-fieldset>
+  <sonic-form-actions>
+    <sonic-button type="primary">Enregistrer</sonic-button>
+    <sonic-button variant="outline">Annuler</sonic-button>
+  </sonic-form-actions>
+</div>
+\`\`\`
+
+## Modal avec contenu
+
+\`\`\`html
+<sonic-modal id="exampleModal">
+  <sonic-modal-title>Confirmation</sonic-modal-title>
+  <sonic-modal-content>
+    Êtes-vous sûr de vouloir continuer ?
+  </sonic-modal-content>
+  <sonic-modal-actions>
+    <sonic-button hideModal>Annuler</sonic-button>
+    <sonic-button type="primary" hideModal>Confirmer</sonic-button>
+  </sonic-modal-actions>
+</sonic-modal>
+\`\`\`
+`;
+  }
+
+  generateFunctionalExamples() {
+    return `# Exemples de composants fonctionnels Concorde
+
+## Chargement de données avec Fetch
+
+\`\`\`html
+<sonic-fetch 
+  serviceURL="https://api.example.com" 
+  endPoint="users" 
+  dataProvider="usersData">
+</sonic-fetch>
+
+<sonic-list dataProvider="usersData" props='$usersData'>
+  <template>
+    <div class="user-card">
+      <h3 data-bind ::inner-html="$name"></h3>
+      <p data-bind ::inner-html="$email"></p>
+    </div>
+  </template>
+</sonic-list>
+\`\`\`
+
+## Navigation avec Router
+
+\`\`\`html
+<sonic-router>
+  <template data-route="#home">
+    <h1>Page d'accueil</h1>
+  </template>
+  <template data-route="#about">
+    <h1>À propos</h1>
+  </template>
+  <template data-route="#contact">
+    <h1>Contact</h1>
+  </template>
+</sonic-router>
+
+<nav>
+  <sonic-button href="#home">Accueil</sonic-button>
+  <sonic-button href="#about">À propos</sonic-button>
+  <sonic-button href="#contact">Contact</sonic-button>
+</nav>
+\`\`\`
+
+## États conditionnels
+
+\`\`\`html
+<sonic-states dataProvider="userData" data-path="status">
+  <template data-value="loading">
+    <sonic-loader></sonic-loader>
+  </template>
+  <template data-value="success">
+    <div class="success-message">Données chargées avec succès</div>
+  </template>
+  <template data-value="error">
+    <sonic-alert type="danger">Erreur lors du chargement</sonic-alert>
+  </template>
+</sonic-states>
+\`\`\`
+`;
+  }
+
+  async run() {
+    await this.initialize();
+
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+
+    console.error('Serveur MCP Concorde démarré');
+  }
+}
+
+// Point d'entrée principal
+async function main() {
+  const server = new ConcordeMCPServer();
+  await server.run();
+}
+
+// Gestion des erreurs non capturées
+process.on('uncaughtException', (error) => {
+  console.error('Erreur non capturée:', error);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Promesse rejetée non gérée:', reason);
+  process.exit(1);
+});
+
+// Point d'entrée principal
+main().catch((error) => {
+  console.error('Erreur lors du démarrage du serveur:', error);
+  process.exit(1);
+});
+
+export { ConcordeMCPServer };