# cursor_dev_tools.py
import asyncio
import subprocess
from pathlib import Path
from fastmcp import FastMCP

# Créer le serveur MCP
mcp = FastMCP("Cursor Development Tools")

@mcp.tool()
def get_project_structure(max_depth: int = 2) -> str:
    """Obtenir la structure actuelle du projet jusqu'à une profondeur spécifiée."""
    try:
        result = subprocess.run(
            ["find", ".", "-type", "f", "-name", "*.py", "-o", "-name", "*.js", "-o", "-name", "*.ts", "-o", "-name", "*.json"],
            capture_output=True,
            text=True,
            cwd="."
        )
        files = result.stdout.strip().split('\n')

        # Organiser par répertoire
        structure = {}
        for file in files:
            if file:
                parts = Path(file).parts
                current = structure
                for part in parts[:-1]:
                    if part not in current:
                        current[part] = {}
                    current = current[part]
                current[parts[-1]] = "file"

        return f"Structure du projet :\n{_format_structure(structure)}"
    except Exception as e:
        return f"Erreur lors de l'obtention de la structure du projet : {str(e)}"

def _format_structure(structure, indent=0):
    """Formater le dictionnaire de structure en tant qu'arbre."""
    result = []
    for key, value in structure.items():
        prefix = "  " * indent + "├── "
        if isinstance(value, dict):
            result.append(f"{prefix}{key}/")
            result.append(_format_structure(value, indent + 1))
        else:
            result.append(f"{prefix}{key}")
    return "\n".join(result)

@mcp.tool()
def run_command(command: str, working_dir: str = ".") -> str:
    """Exécuter une commande shell dans le répertoire spécifié."""
    try:
        result = subprocess.run(
            command,
            shell=True,
            capture_output=True,
            text=True,
            cwd=working_dir,
            timeout=30
        )

        output = []
        if result.stdout:
            output.append(f"SORTIE STANDARD :\n{result.stdout}")
        if result.stderr:
            output.append(f"ERREUR STANDARD :\n{result.stderr}")

        output.append(f"Code de retour : {result.returncode}")
        return "\n\n".join(output)

    except subprocess.TimeoutExpired:
        return "La commande a expiré après 30 secondes"
    except Exception as e:
        return f"Erreur lors de l'exécution de la commande : {str(e)}"

@mcp.tool()
def search_code(pattern: str, file_extension: str = "py") -> str:
    """Rechercher des motifs de code dans les fichiers du projet."""
    try:
        result = subprocess.run(
            ["grep", "-r", "--include", f"*.{file_extension}", pattern, "."],
            capture_output=True,
            text=True
        )

        if result.returncode == 0:
            return f"Correspondances trouvées pour '{pattern}' :\n\n{result.stdout}"
        else:
            return f"Aucune correspondance trouvée pour le motif '{pattern}' dans les fichiers *.{file_extension}"

    except Exception as e:
        return f"Erreur lors de la recherche de code : {str(e)}"

@mcp.resource("file://project-docs")
async def get_project_docs():
    """Fournit la documentation du projet et les fichiers README."""
    docs = []

    # Rechercher les fichiers de documentation courants
    doc_files = ["README.md", "README.rst", "docs/README.md", "CONTRIBUTING.md"]

    for doc_file in doc_files:
        path = Path(doc_file)
        if path.exists():
            try:
                content = path.read_text()
                docs.append(f"=== {doc_file} ===\n{content}\n")
            except Exception as e:
                docs.append(f"=== {doc_file} ===\nErreur lors de la lecture du fichier : {str(e)}\n")

    if not docs:
        docs.append("Aucun fichier de documentation trouvé à la racine du projet.")

    return "\n".join(docs)

if __name__ == "__main__":
    mcp.run()

{
  "mcpServers": {
    "fastmcp-dev-tools": {
      "command": "python",
      "args": ["cursor_dev_tools.py"],
      "env": {}
    }
  }
}

{
  "mcpServers": {
    "fastmcp-dev-tools": {
      "command": "python",
      "args": ["/chemin/vers/votre/cursor_dev_tools.py"],
      "env": {}
    }
  }
}

{
  "mcpServers": {
    "fastmcp-api-server": {
      "command": "python",
      "args": ["api_server.py"],
      "env": {
        "API_KEY": "votre-cle-api-ici",
        "DEBUG": "true"
      }
    }
  }
}

import base64
from fastmcp import FastMCP

mcp = FastMCP("Générateur d'images")

@mcp.tool()
def generate_diagram() -> dict:
    """Génère un diagramme simple et le retourne en tant qu'image."""
    # Créer ou générer votre image
    with open("diagram.png", "rb") as f:
        image_data = base64.b64encode(f.read()).decode()

    return {
        "content": [
            {
                "type": "image",
                "data": image_data,
                "mimeType": "image/png"
            }
        ]
    }

@mcp.resource("file://git-status")
async def get_git_status():
    """Fournit le statut actuel du dépôt Git."""
    try:
        # Obtenir le statut Git
        status_result = subprocess.run(
            ["git", "status", "--porcelain"],
            capture_output=True,
            text=True
        )

        # Obtenir les commits récents
        log_result = subprocess.run(
            ["git", "log", "--oneline", "-10"],
            capture_output=True,
            text=True
        )

        return f"Statut Git :\n{status_result.stdout}\n\nCommits récents :\n{log_result.stdout}"

    except Exception as e:
        return f"Erreur lors de l'obtention du statut Git : {str(e)}"

# Exécutez votre serveur directement
python cursor_dev_tools.py

# Testez avec les outils clients MCP
npx @modelcontextprotocol/inspector cursor_dev_tools.py

# Serveur d'outils de développement améliorés
from fastmcp import FastMCP
import subprocess
import json

mcp = FastMCP("Outils de développement avancés")

@mcp.tool()
def run_tests(test_pattern: str = "") -> str:
    """Exécute les tests du projet avec un filtrage de motif optionnel."""
    cmd = ["python", "-m", "pytest"]
    if test_pattern:
        cmd.extend(["-k", test_pattern])

    result = subprocess.run(cmd, capture_output=True, text=True)
    return f"Résultats des tests :\n{result.stdout}\n{result.stderr}"

@mcp.tool()
def format_code() -> str:
    """Formate le code Python en utilisant black."""
    result = subprocess.run(
        ["black", ".", "--check", "--diff"],
        capture_output=True,
        text=True
    )

    if result.returncode == 0:
        return "Le code est déjà formaté correctement"
    else:
        return f"Suggestions de formatage de code :\n{result.stdout}"

@mcp.tool()
def check_dependencies() -> str:
    """Vérifie les dépendances de paquets obsolètes."""
    result = subprocess.run(
        ["pip", "list", "--outdated", "--format", "json"],
        capture_output=True,
        text=True
    )

    try:
        outdated = json.loads(result.stdout)
        if outdated:
            output = "Paquets obsolètes :\n"
            for pkg in outdated:
                output += f"- {pkg['name']}: {pkg['version']} -> {pkg['latest_version']}\n"
            return output
        else:
            return "Tous les paquets sont à jour !"
    except:
        return "Erreur lors de la vérification des dépendances"

@mcp.tool()
def fetch_api_docs(api_url: str) -> str:
    """Récupère la documentation API depuis les points de terminaison OpenAPI/Swagger."""
    import requests

    try:
        response = requests.get(f"{api_url}/openapi.json", timeout=10)
        if response.status_code == 200:
            api_spec = response.json()
            return f"Documentation API pour {api_url}:\n{json.dumps(api_spec, indent=2)}"
        else:
            return f"Échec de la récupération des docs API : HTTP {response.status_code}"
    except Exception as e:
        return f"Erreur lors de la récupération des docs API : {str(e)}"