@enokdev/springdocs-mcp 1.1.0

package/publish.sh

@@ -0,0 +1,130 @@
+#!/bin/bash
+
+# Script de publication automatique pour @enokdev/springdocs-mcp
+# Auteur: EnokDev (https://github.com/tky0065)
+
+set -e
+
+echo "🌱 Publication de Spring Documentation MCP Server"
+echo "=================================================="
+echo ""
+
+# Vérifications préliminaires
+echo "🔍 Vérifications pré-publication..."
+
+# Vérifier que nous sommes connectés à npm
+NPM_USER=$(npm whoami 2>/dev/null || echo "")
+if [ "$NPM_USER" != "enokdev" ]; then
+    echo "❌ Erreur: Vous devez être connecté à npm en tant qu'enokdev"
+    echo "Exécutez: npm login"
+    exit 1
+fi
+
+echo "✅ Connecté à npm en tant que: $NPM_USER"
+
+# Vérifier que le build fonctionne
+echo "🔨 Compilation du projet..."
+npm run build
+
+# Exécuter les tests
+echo "🧪 Exécution des tests..."
+npm test
+
+# Vérifier la configuration Git
+if ! git remote get-url origin | grep -q "tky0065/springdocs-mcp"; then
+    echo "⚠️  Attention: L'origin Git ne semble pas pointer vers tky0065/springdocs-mcp"
+    echo "Origin actuel: $(git remote get-url origin)"
+    read -p "Continuer quand même? (y/N): " -n 1 -r
+    echo
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        exit 1
+    fi
+fi
+
+# Afficher la version actuelle
+CURRENT_VERSION=$(node -p "require('./package.json').version")
+echo "📦 Version actuelle: $CURRENT_VERSION"
+
+# Demander le type de mise à jour
+echo ""
+echo "Type de mise à jour:"
+echo "1) patch (1.1.0 -> 1.1.1) - Corrections de bugs"
+echo "2) minor (1.1.0 -> 1.2.0) - Nouvelles fonctionnalités"
+echo "3) major (1.1.0 -> 2.0.0) - Changements incompatibles"
+echo "4) Garder la version actuelle"
+
+read -p "Votre choix (1-4): " -n 1 -r
+echo
+
+case $REPLY in
+    1) VERSION_TYPE="patch" ;;
+    2) VERSION_TYPE="minor" ;;
+    3) VERSION_TYPE="major" ;;
+    4) VERSION_TYPE="" ;;
+    *) echo "❌ Choix invalide"; exit 1 ;;
+esac
+
+# Mise à jour de version si nécessaire
+if [ ! -z "$VERSION_TYPE" ]; then
+    echo "📝 Mise à jour de version ($VERSION_TYPE)..."
+    npm version $VERSION_TYPE --no-git-tag-version
+    NEW_VERSION=$(node -p "require('./package.json').version")
+    echo "✅ Nouvelle version: $NEW_VERSION"
+else
+    NEW_VERSION=$CURRENT_VERSION
+    echo "📌 Conservation de la version: $NEW_VERSION"
+fi
+
+# Test final du package
+echo "🔍 Test final du package..."
+npm pack --dry-run > /dev/null
+
+# Confirmation finale
+echo ""
+echo "🚀 Prêt pour la publication:"
+echo "   Package: @enokdev/springdocs-mcp@$NEW_VERSION"
+echo "   Registry: https://www.npmjs.com/package/@enokdev/springdocs-mcp"
+echo "   Repository: https://github.com/tky0065/springdocs-mcp"
+echo ""
+
+read -p "Confirmer la publication? (y/N): " -n 1 -r
+echo
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "❌ Publication annulée"
+    exit 1
+fi
+
+# Git commit et push
+if [ ! -z "$VERSION_TYPE" ]; then
+    echo "📤 Envoi vers GitHub..."
+    git add .
+    git commit -m "Release v$NEW_VERSION"
+    git tag "v$NEW_VERSION"
+    git push origin main --tags
+    echo "✅ Code envoyé vers GitHub avec tag v$NEW_VERSION"
+fi
+
+# Publication npm
+echo "📦 Publication sur npm..."
+npm publish --access public
+
+echo ""
+echo "🎉 Publication réussie!"
+echo ""
+echo "📋 Informations de publication:"
+echo "   📦 Package: https://www.npmjs.com/package/@enokdev/springdocs-mcp"
+echo "   🐙 GitHub: https://github.com/tky0065/springdocs-mcp"
+echo "   📊 Stats: https://npm-stat.com/charts.html?package=@enokdev/springdocs-mcp"
+echo ""
+echo "📥 Installation pour les utilisateurs:"
+echo "   npm install -g @enokdev/springdocs-mcp"
+echo ""
+echo "🔧 Configuration Claude Desktop:"
+echo '   {"mcpServers": {"spring-docs": {"command": "springdocs-mcp"}}}'
+echo ""
+echo "🌟 N'oubliez pas de:"
+echo "   • Annoncer sur les réseaux sociaux"
+echo "   • Mettre à jour la documentation si nécessaire"
+echo "   • Répondre aux issues GitHub"
+echo ""
+echo "Merci d'avoir publié un outil utile pour la communauté Spring! 🌱"

package/src/index.ts

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, CallToolRequest, ListToolsRequest } from "@modelcontextprotocol/sdk/types.js";
+import { SpringBootDocsService } from "./services/springboot-docs.js";
+import { ToolDefinitions } from "./tools/index.js";
+
+/**
+ * Serveur MCP pour accéder à la documentation Spring Boot
+ */
+class SpringBootMCPServer {
+  private server: Server;
+  private docsService: SpringBootDocsService;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: "springboot-mcp-server",
+        version: "1.1.0",
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.docsService = new SpringBootDocsService();
+    this.setupToolHandlers();
+  }
+
+  private setupToolHandlers() {
+    // Gestionnaire pour lister les outils disponibles
+    this.server.setRequestHandler(ListToolsRequestSchema, async (request: ListToolsRequest) => {
+      return {
+        tools: ToolDefinitions.getToolList(),
+      };
+    });
+
+    // Gestionnaire pour exécuter un outil
+    this.server.setRequestHandler(CallToolRequestSchema, async (request: CallToolRequest) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        switch (name) {
+          case "search_spring_docs":
+            return await this.handleSearchDocs(args);
+          
+          case "search_spring_projects":
+            return await this.handleSearchProjects(args);
+          
+          case "get_spring_project":
+            return await this.handleGetProject(args);
+          
+          case "get_all_spring_guides":
+            return await this.handleGetAllGuides(args);
+          
+          case "get_spring_guide":
+            return await this.handleGetGuide(args);
+          
+          case "get_spring_reference":
+            return await this.handleGetReference(args);
+          
+          case "search_spring_concepts":
+            return await this.handleSearchConcepts(args);
+          
+          default:
+            throw new Error(`Outil inconnu: ${name}`);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Erreur inconnue";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Erreur lors de l'exécution de l'outil ${name}: ${errorMessage}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    });
+  }
+
+  private async handleSearchProjects(args: any) {
+    const { query, limit = 10 } = args;
+    
+    if (!query || typeof query !== "string") {
+      throw new Error("Le paramètre 'query' est requis et doit être une chaîne de caractères");
+    }
+
+    const results = await this.docsService.searchSpringProjects(query, limit);
+    
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Projets Spring trouvés pour "${query}":\n\n${this.formatSearchResults(results)}`,
+        },
+      ],
+    };
+  }
+
+  private async handleGetProject(args: any) {
+    const { projectName } = args;
+    
+    if (!projectName || typeof projectName !== "string") {
+      throw new Error("Le paramètre 'projectName' est requis et doit être une chaîne de caractères");
+    }
+
+    const project = await this.docsService.getSpringProject(projectName);
+    
+    return {
+      content: [
+        {
+          type: "text",
+          text: project,
+        },
+      ],
+    };
+  }
+
+  private async handleGetAllGuides(args: any) {
+    const { category, limit = 20 } = args;
+
+    const results = await this.docsService.getAllSpringGuides(category, limit);
+    
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Guides Spring disponibles${category ? ` dans la catégorie "${category}"` : ""}:\n\n${this.formatSearchResults(results)}`,
+        },
+      ],
+    };
+  }
+
+  private async handleSearchDocs(args: any) {
+    const { query, docType = "all", limit = 10 } = args;
+    
+    if (!query || typeof query !== "string") {
+      throw new Error("Le paramètre 'query' est requis et doit être une chaîne de caractères");
+    }
+
+    const results = await this.docsService.searchDocumentation(query, docType, limit);
+    
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Résultats de recherche pour "${query}":\n\n${this.formatSearchResults(results)}`,
+        },
+      ],
+    };
+  }
+
+  private async handleGetGuide(args: any) {
+    const { guideId } = args;
+    
+    if (!guideId || typeof guideId !== "string") {
+      throw new Error("Le paramètre 'guideId' est requis et doit être une chaîne de caractères");
+    }
+
+    const guide = await this.docsService.getGuide(guideId);
+    
+    return {
+      content: [
+        {
+          type: "text",
+          text: guide,
+        },
+      ],
+    };
+  }
+
+  private async handleGetReference(args: any) {
+    const { section, subsection } = args;
+    
+    if (!section || typeof section !== "string") {
+      throw new Error("Le paramètre 'section' est requis et doit être une chaîne de caractères");
+    }
+
+    const reference = await this.docsService.getReference(section, subsection);
+    
+    return {
+      content: [
+        {
+          type: "text",
+          text: reference,
+        },
+      ],
+    };
+  }
+
+  private async handleSearchConcepts(args: any) {
+    const { concept, category } = args;
+    
+    if (!concept || typeof concept !== "string") {
+      throw new Error("Le paramètre 'concept' est requis et doit être une chaîne de caractères");
+    }
+
+    const results = await this.docsService.searchConcepts(concept, category);
+    
+    return {
+      content: [
+        {
+          type: "text",
+          text: this.formatConceptResults(results),
+        },
+      ],
+    };
+  }
+
+  private formatSearchResults(results: any[]): string {
+    if (results.length === 0) {
+      return "Aucun résultat trouvé.";
+    }
+
+    return results
+      .map((result, index) => {
+        return `${index + 1}. **${result.title}**
+   Type: ${result.type}
+   URL: ${result.url}
+   Description: ${result.description || "Aucune description disponible"}
+   
+`;
+      })
+      .join("\n");
+  }
+
+  private formatConceptResults(results: any): string {
+    if (!results || Object.keys(results).length === 0) {
+      return "Aucun concept trouvé.";
+    }
+
+    let formatted = `# Concepts Spring Boot\n\n`;
+    
+    for (const [category, concepts] of Object.entries(results)) {
+      formatted += `## ${category}\n\n`;
+      
+      if (Array.isArray(concepts)) {
+        concepts.forEach((concept: any) => {
+          formatted += `- **${concept.name}**: ${concept.description}\n`;
+          if (concept.examples && concept.examples.length > 0) {
+            formatted += `  Exemples: ${concept.examples.join(", ")}\n`;
+          }
+        });
+      }
+      
+      formatted += "\n";
+    }
+
+    return formatted;
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("Serveur MCP Spring Boot démarré sur stdio");
+  }
+}
+
+// Point d'entrée principal
+async function main() {
+  const server = new SpringBootMCPServer();
+  await server.run();
+}
+
+// Gestion des erreurs
+process.on("SIGINT", async () => {
+  console.error("Arrêt du serveur...");
+  process.exit(0);
+});
+
+process.on("unhandledRejection", (reason: any, promise: Promise<any>) => {
+  console.error("Rejet de promesse non géré:", reason);
+  process.exit(1);
+});
+
+// Démarrage du serveur
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error("Erreur fatale:", error);
+    process.exit(1);
+  });
+}