@supersoniks/concorde 3.2.0 → 3.2.1

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

@@ -0,0 +1,801 @@
+#!/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())