@supersoniks/concorde 3.2.1 → 3.2.2

package/mcp-server/concorde-mcp-server.py

@@ -1,801 +0,0 @@
-#!/usr/bin/env python3
-"""
-Serveur MCP pour Concorde - Framework de composants Web
-Permet à l'IA de Cursor d'accéder facilement à toute la documentation et au code de Concorde
-"""
-
-import json
-import os
-import re
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
-import asyncio
-from dataclasses import dataclass
-from mcp.server import Server
-from mcp.server.models import InitializationOptions
-from mcp.server.stdio import stdio_server
-from mcp.types import (
-    Resource, 
-    Tool, 
-    TextContent, 
-    ImageContent, 
-    EmbeddedResource,
-    CallToolRequest,
-    CallToolResult,
-    ListResourcesRequest,
-    ListResourcesResult,
-    ListToolsRequest,
-    ListToolsResult,
-    ReadResourceRequest,
-    ReadResourceResult
-)
-
-# Configuration du projet Concorde
-CONCORDE_ROOT = Path(__file__).parent.parent
-SRC_PATH = CONCORDE_ROOT / "src"
-DOCS_PATH = CONCORDE_ROOT / "docs"
-CORE_PATH = SRC_PATH / "core"
-COMPONENTS_PATH = CORE_PATH / "components"
-
-@dataclass
-class ComponentInfo:
-    """Information sur un composant Concorde"""
-    name: str
-    tag_name: str
-    category: str  # 'ui' ou 'functional'
-    file_path: Path
-    doc_path: Optional[Path]
-    description: str
-    props: List[Dict[str, Any]]
-    examples: List[str]
-
-class ConcordeMCPServer:
-    """Serveur MCP pour Concorde"""
-    
-    def __init__(self):
-        self.server = Server("concorde-mcp")
-        self.components: Dict[str, ComponentInfo] = {}
-        self.documentation: Dict[str, str] = {}
-        self._setup_handlers()
-        self._load_components()
-        self._load_documentation()
-    
-    def _setup_handlers(self):
-        """Configure les handlers MCP"""
-        
-        @self.server.list_resources()
-        async def list_resources() -> ListResourcesResult:
-            """Liste toutes les ressources disponibles"""
-            resources = []
-            
-            # Ressources de composants
-            for comp_name, comp_info in self.components.items():
-                resources.append(Resource(
-                    uri=f"concorde://component/{comp_name}",
-                    name=f"Composant {comp_name}",
-                    description=comp_info.description,
-                    mimeType="text/markdown"
-                ))
-            
-            # Ressources de documentation
-            for doc_name, doc_content in self.documentation.items():
-                resources.append(Resource(
-                    uri=f"concorde://docs/{doc_name}",
-                    name=f"Documentation {doc_name}",
-                    description=f"Documentation Concorde: {doc_name}",
-                    mimeType="text/markdown"
-                ))
-            
-            # Ressources d'exemples
-            resources.append(Resource(
-                uri="concorde://examples/ui-components",
-                name="Exemples composants UI",
-                description="Exemples d'utilisation des composants UI",
-                mimeType="text/markdown"
-            ))
-            
-            resources.append(Resource(
-                uri="concorde://examples/functional-components",
-                name="Exemples composants fonctionnels",
-                description="Exemples d'utilisation des composants fonctionnels",
-                mimeType="text/markdown"
-            ))
-            
-            return ListResourcesResult(resources=resources)
-        
-        @self.server.read_resource()
-        async def read_resource(uri: str) -> ReadResourceResult:
-            """Lit une ressource"""
-            if uri.startswith("concorde://component/"):
-                comp_name = uri.replace("concorde://component/", "")
-                if comp_name in self.components:
-                    comp_info = self.components[comp_name]
-                    content = self._generate_component_doc(comp_info)
-                    return ReadResourceResult(contents=[TextContent(type="text", text=content)])
-            
-            elif uri.startswith("concorde://docs/"):
-                doc_name = uri.replace("concorde://docs/", "")
-                if doc_name in self.documentation:
-                    return ReadResourceResult(contents=[TextContent(type="text", text=self.documentation[doc_name])])
-            
-            elif uri == "concorde://examples/ui-components":
-                content = self._generate_ui_examples()
-                return ReadResourceResult(contents=[TextContent(type="text", text=content)])
-            
-            elif uri == "concorde://examples/functional-components":
-                content = self._generate_functional_examples()
-                return ReadResourceResult(contents=[TextContent(type="text", text=content)])
-            
-            return ReadResourceResult(contents=[TextContent(type="text", text="Ressource non trouvée")])
-        
-        @self.server.list_tools()
-        async def list_tools() -> ListToolsResult:
-            """Liste tous les outils disponibles"""
-            tools = [
-                Tool(
-                    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"]
-                    }
-                ),
-                Tool(
-                    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"]
-                    }
-                ),
-                Tool(
-                    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"]
-                    }
-                ),
-                Tool(
-                    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"}
-                                    }
-                                }
-                            }
-                        }
-                    }
-                ),
-                Tool(
-                    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"]
-                            }
-                        }
-                    }
-                ),
-                Tool(
-                    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 ListToolsResult(tools=tools)
-        
-        @self.server.call_tool()
-        async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
-            """Exécute un outil"""
-            if name == "search_component":
-                return await self._search_component(arguments["query"])
-            elif name == "get_component_info":
-                return await self._get_component_info(arguments["component_name"])
-            elif name == "generate_component_code":
-                return await self._generate_component_code(
-                    arguments["component_name"],
-                    arguments.get("properties", {}),
-                    arguments.get("content", "")
-                )
-            elif name == "get_form_example":
-                return await self._get_form_example(arguments.get("fields", []))
-            elif name == "get_theme_info":
-                return await self._get_theme_info(arguments.get("theme", "light"))
-            elif name == "get_icons_list":
-                return await self._get_icons_list(arguments.get("library", "core"))
-            else:
-                return CallToolResult(content=[TextContent(type="text", text=f"Outil inconnu: {name}")])
-    
-    def _load_components(self):
-        """Charge tous les composants Concorde"""
-        
-        # Composants UI
-        ui_path = COMPONENTS_PATH / "ui"
-        for comp_dir in ui_path.iterdir():
-            if comp_dir.is_dir() and not comp_dir.name.startswith("_"):
-                self._load_component(comp_dir, "ui")
-        
-        # Composants fonctionnels
-        functional_path = COMPONENTS_PATH / "functional"
-        for comp_dir in functional_path.iterdir():
-            if comp_dir.is_dir():
-                self._load_component(comp_dir, "functional")
-    
-    def _load_component(self, comp_dir: Path, category: str):
-        """Charge un composant spécifique"""
-        comp_name = comp_dir.name
-        tag_name = f"sonic-{comp_name}"
-        
-        # Trouve le fichier principal
-        main_file = comp_dir / f"{comp_name}.ts"
-        if not main_file.exists():
-            return
-        
-        # Trouve le fichier de documentation
-        doc_file = comp_dir / f"{comp_name}.md"
-        
-        # Lit le contenu du composant
-        try:
-            with open(main_file, 'r', encoding='utf-8') as f:
-                content = f.read()
-        except:
-            return
-        
-        # Extrait les propriétés du composant
-        props = self._extract_properties(content)
-        
-        # Extrait la description
-        description = self._extract_description(content)
-        
-        # Charge la documentation si elle existe
-        doc_content = ""
-        if doc_file.exists():
-            try:
-                with open(doc_file, 'r', encoding='utf-8') as f:
-                    doc_content = f.read()
-            except:
-                pass
-        
-        # Extrait les exemples de la documentation
-        examples = self._extract_examples(doc_content)
-        
-        comp_info = ComponentInfo(
-            name=comp_name,
-            tag_name=tag_name,
-            category=category,
-            file_path=main_file,
-            doc_path=doc_file if doc_file.exists() else None,
-            description=description,
-            props=props,
-            examples=examples
-        )
-        
-        self.components[comp_name] = comp_info
-    
-    def _extract_properties(self, content: str) -> List[Dict[str, Any]]:
-        """Extrait les propriétés du composant"""
-        props = []
-        
-        # Recherche les décorateurs @property
-        property_pattern = r'@property\([^)]*\)\s+(\w+)(?::\s*([^=]+))?'
-        matches = re.findall(property_pattern, content)
-        
-        for match in matches:
-            prop_name = match[0]
-            prop_type = match[1] if match[1] else "string"
-            
-            # Recherche les commentaires JSDoc pour cette propriété
-            comment_pattern = rf'/\*\*\s*\n\s*\*\s*([^\n]+)'
-            comment_match = re.search(comment_pattern, content)
-            description = comment_match.group(1).strip() if comment_match else ""
-            
-            props.append({
-                "name": prop_name,
-                "type": prop_type,
-                "description": description
-            })
-        
-        return props
-    
-    def _extract_description(self, content: str) -> str:
-        """Extrait la description du composant"""
-        # Recherche les commentaires de classe
-        class_pattern = r'/\*\*\s*\n\s*\*\s*([^\n]+)'
-        match = re.search(class_pattern, content)
-        if match:
-            return match.group(1).strip()
-        
-        # Recherche le nom de la classe
-        class_name_pattern = r'export class (\w+)'
-        match = re.search(class_name_pattern, content)
-        if match:
-            return f"Composant {match.group(1)}"
-        
-        return "Composant Concorde"
-    
-    def _extract_examples(self, doc_content: str) -> List[str]:
-        """Extrait les exemples de la documentation"""
-        examples = []
-        
-        # Recherche les blocs sonic-code
-        code_pattern = r'<sonic-code>(.*?)</sonic-code>'
-        matches = re.findall(code_pattern, doc_content, re.DOTALL)
-        
-        for match in matches:
-            # Nettoie le contenu
-            example = match.strip()
-            if example:
-                examples.append(example)
-        
-        return examples
-    
-    def _load_documentation(self):
-        """Charge la documentation générale"""
-        # Documentation des concepts de base
-        self.documentation["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é
-"""
-
-        self.documentation["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 def _search_component(self, query: str) -> CallToolResult:
-        """Recherche un composant"""
-        results = []
-        query_lower = query.lower()
-        
-        for comp_name, comp_info in self.components.items():
-            if (query_lower in comp_name.lower() or 
-                query_lower in comp_info.description.lower() or
-                query_lower in comp_info.tag_name.lower()):
-                results.append(f"- **{comp_info.tag_name}** ({comp_info.category}): {comp_info.description}")
-        
-        if results:
-            content = f"Composants trouvés pour '{query}':\n\n" + "\n".join(results)
-        else:
-            content = f"Aucun composant trouvé pour '{query}'"
-        
-        return CallToolResult(content=[TextContent(type="text", text=content)])
-    
-    async def _get_component_info(self, component_name: str) -> CallToolResult:
-        """Obtient des informations sur un composant"""
-        if component_name not in self.components:
-            return CallToolResult(content=[TextContent(type="text", text=f"Composant '{component_name}' non trouvé")])
-        
-        comp_info = self.components[component_name]
-        
-        # Génère la documentation complète
-        content = f"""# {comp_info.tag_name}
-
-**Catégorie:** {comp_info.category}
-**Description:** {comp_info.description}
-
-## Propriétés
-
-"""
-        
-        for prop in comp_info.props:
-            content += f"- **{prop['name']}** ({prop['type']}): {prop['description']}\n"
-        
-        if comp_info.examples:
-            content += "\n## Exemples\n\n"
-            for i, example in enumerate(comp_info.examples[:3], 1):  # Limite à 3 exemples
-                content += f"### Exemple {i}\n\n```html\n{example}\n```\n\n"
-        
-        return CallToolResult(content=[TextContent(type="text", text=content)])
-    
-    async def _generate_component_code(self, component_name: str, properties: Dict[str, Any], content: str = "") -> CallToolResult:
-        """Génère du code pour un composant"""
-        if component_name not in self.components:
-            return CallToolResult(content=[TextContent(type="text", text=f"Composant '{component_name}' non trouvé")])
-        
-        comp_info = self.components[component_name]
-        tag_name = comp_info.tag_name
-        
-        # Génère les attributs
-        attributes = []
-        for key, value in properties.items():
-            if isinstance(value, bool):
-                if value:
-                    attributes.append(key)
-            else:
-                attributes.append(f'{key}="{value}"')
-        
-        # Génère le code HTML
-        if content:
-            html_code = f"<{tag_name} {' '.join(attributes)}>{content}</{tag_name}>"
-        else:
-            html_code = f"<{tag_name} {' '.join(attributes)}></{tag_name}>"
-        
-        return CallToolResult(content=[TextContent(type="text", text=html_code)])
-    
-    async def _get_form_example(self, fields: List[Dict[str, Any]]) -> CallToolResult:
-        """Génère un exemple de formulaire"""
-        if not fields:
-            # 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}
-            ]
-        
-        form_html = '<div formDataProvider="exampleForm">\n'
-        
-        for field in fields:
-            field_name = field["name"]
-            field_type = field["type"]
-            field_label = field["label"]
-            field_required = field.get("required", False)
-            
-            if field_type == "checkbox":
-                form_html += f'  <sonic-checkbox name="{field_name}"'
-                if field_required:
-                    form_html += " required"
-                form_html += f'>{field_label}</sonic-checkbox>\n'
-            else:
-                form_html += f'  <sonic-input name="{field_name}" type="{field_type}" label="{field_label}"'
-                if field_required:
-                    form_html += " required"
-                form_html += '></sonic-input>\n'
-        
-        form_html += '  <sonic-form-actions>\n'
-        form_html += '    <sonic-button type="primary">Valider</sonic-button>\n'
-        form_html += '    <sonic-button variant="outline">Annuler</sonic-button>\n'
-        form_html += '  </sonic-form-actions>\n'
-        form_html += '</div>'
-        
-        return CallToolResult(content=[TextContent(type="text", text=form_html)])
-    
-    async def _get_theme_info(self, theme: str) -> CallToolResult:
-        """Obtient des informations sur le thème"""
-        theme_info = {
-            "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"
-            }
-        }
-        
-        info = theme_info.get(theme, theme_info["light"])
-        
-        content = f"""# Thème {theme}
-
-{info['description']}
-
-## Utilisation
-
-```html
-<sonic-theme theme="{theme}">
-  <!-- Vos composants ici -->
-</sonic-theme>
-```
-
-"""
-        
-        if "colors" in info and isinstance(info["colors"], dict):
-            content += "## Couleurs\n\n"
-            for color_name, color_value in info["colors"].items():
-                content += f"- **{color_name}**: `{color_value}`\n"
-        
-        return CallToolResult(content=[TextContent(type="text", text=content)])
-    
-    async def _get_icons_list(self, library: str) -> CallToolResult:
-        """Liste les icônes disponibles"""
-        icons_info = {
-            "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"
-        }
-        
-        if library == "core":
-            icons = icons_info["core"]
-            content = f"""# Icônes Core Concorde
-
-## Utilisation
-
-```html
-<sonic-icon library="core" name="nom-de-l-icone"></sonic-icon>
-```
-
-## Icônes disponibles
-
-"""
-            for icon in icons:
-                content += f"- **{icon}**: `<sonic-icon library="core" name="{icon}"></sonic-icon>`\n"
-        else:
-            content = f"""# Bibliothèque d'icônes {library}
-
-{icons_info[library]}
-
-## Utilisation
-
-```html
-<sonic-icon library="{library}" name="nom-de-l-icone"></sonic-icon>
-```
-
-Pour les icônes FontAwesome, vous pouvez spécifier le préfixe :
-```html
-<sonic-icon library="fontAwesome" prefix="solid" name="home"></sonic-icon>
-<sonic-icon library="fontAwesome" prefix="regular" name="user"></sonic-icon>
-```
-"""
-        
-        return CallToolResult(content=[TextContent(type="text", text=content)])
-    
-    def _generate_component_doc(self, comp_info: ComponentInfo) -> str:
-        """Génère la documentation complète d'un composant"""
-        content = f"""# {comp_info.tag_name}
-
-**Catégorie:** {comp_info.category}
-**Description:** {comp_info.description}
-
-## Propriétés
-
-"""
-        
-        for prop in comp_info.props:
-            content += f"- **{prop['name']}** ({prop['type']}): {prop['description']}\n"
-        
-        if comp_info.examples:
-            content += "\n## Exemples\n\n"
-            for i, example in enumerate(comp_info.examples, 1):
-                content += f"### Exemple {i}\n\n```html\n{example}\n```\n\n"
-        
-        return content
-    
-    def _generate_ui_examples(self) -> str:
-        """Génère des exemples de composants UI"""
-        content = """# 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>
-```
-"""
-        return content
-    
-    def _generate_functional_examples(self) -> str:
-        """Génère des exemples de composants fonctionnels"""
-        content = """# 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>
-```
-"""
-        return content
-    
-    async def run(self):
-        """Lance le serveur MCP"""
-        async with stdio_server() as (read_stream, write_stream):
-            await self.server.run(
-                read_stream,
-                write_stream,
-                InitializationOptions(
-                    server_name="concorde-mcp",
-                    server_version="1.0.0",
-                    capabilities=self.server.get_capabilities(
-                        notification_options=None,
-                        experimental_capabilities={}
-                    )
-                )
-            )
-
-async def main():
-    """Point d'entrée principal"""
-    server = ConcordeMCPServer()
-    await server.run()
-
-if __name__ == "__main__":
-    asyncio.run(main())