@miocid152/sonarqube-mcp-server 1.0.0

package/PUBLISH.md

@@ -0,0 +1,49 @@
+# Guía para Publicar en npm
+
+## 1. Iniciar sesión en npm
+```bash
+npm login
+```
+Te pedirá:
+- Username
+- Password
+- Email
+- OTP (si tienes 2FA activado)
+
+## 2. Verificar que estás logueado
+```bash
+npm whoami
+```
+
+## 3. Verificar el package.json
+```bash
+cat package.json
+```
+
+## 4. Publicar el paquete
+```bash
+cd /Volumes/erick/Erick/proyectos/ProyectosEKT/sonarqube-mcp-server
+npm publish
+```
+
+## 5. Verificar la publicación
+```bash
+npm view sonarqube-mcp-server
+```
+
+## 6. Instalar globalmente desde npm
+```bash
+npm install -g sonarqube-mcp-server
+```
+
+## Notas importantes:
+- El nombre "sonarqube-mcp-server" debe estar disponible en npm
+- Si ya existe, deberás cambiar el nombre en package.json
+- La versión actual es 1.0.0
+- Para actualizar: cambia la versión en package.json y ejecuta `npm publish` de nuevo
+
+## Si el nombre está ocupado:
+Cambia el nombre en package.json a algo como:
+- @tu-usuario/sonarqube-mcp-server (scoped package)
+- sonarqube-mcp-server-ekt
+- mcp-sonarqube-server

package/README.md

@@ -0,0 +1,82 @@
+# SonarQube MCP Server
+
+Servidor MCP (Model Context Protocol) para integración con SonarQube que permite obtener reglas de calidad y generar código conforme.
+
+## Instalación
+
+```bash
+# Instalar globalmente
+npm install -g sonarqube-mcp-server
+
+# O instalar desde el directorio local
+cd sonarqube-mcp-server
+npm install -g .
+```
+
+## Configuración
+
+Configurar variables de entorno:
+
+```bash
+export SONAR_URL="https://sonar.tu-empresa.com"
+export SONAR_TOKEN="tu_token_de_sonar"
+```
+
+## Uso
+
+### Ejecutar el servidor MCP
+
+```bash
+sonarqube-mcp
+```
+
+### Herramientas disponibles
+
+1. **get_sonar_rules** - Obtener reglas activas
+   - `language`: Lenguaje de programación (java, javascript, python, etc.)
+   - `projectKey`: Clave del proyecto (opcional)
+
+2. **get_quality_profile** - Obtener perfil de calidad
+   - `projectKey`: Clave del proyecto
+
+3. **get_project_issues** - Obtener issues del proyecto
+   - `projectKey`: Clave del proyecto
+   - `resolved`: Incluir issues resueltos (default: false)
+
+4. **validate_code_rules** - Obtener reglas para validación
+   - `language`: Lenguaje de programación
+   - `severity`: Severidad mínima (INFO, MINOR, MAJOR, CRITICAL, BLOCKER)
+
+## Ejemplo de configuración en Claude Desktop
+
+Agregar al archivo de configuración de Claude Desktop:
+
+```json
+{
+  "mcpServers": {
+    "sonarqube": {
+      "command": "sonarqube-mcp",
+      "env": {
+        "SONAR_URL": "https://sonar.tu-empresa.com",
+        "SONAR_TOKEN": "tu_token_aqui"
+      }
+    }
+  }
+}
+```
+
+## Obtener Token de SonarQube
+
+1. Ir a SonarQube → User → My Account → Security
+2. Generar nuevo token
+3. Copiar el token generado
+
+## Desarrollo
+
+```bash
+# Instalar dependencias
+npm install
+
+# Ejecutar en modo desarrollo
+npm start
+```

package/bin/sonarqube-mcp.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+const { SonarQubeMCPServer } = require('../index.js');
+
+async function main() {
+  const sonarUrl = process.env.SONAR_URL;
+  const sonarToken = process.env.SONAR_TOKEN;
+
+  if (!sonarUrl || !sonarToken) {
+    console.error('Error: SONAR_URL and SONAR_TOKEN environment variables are required');
+    console.error('Usage: SONAR_URL=https://sonar.company.com SONAR_TOKEN=your_token sonarqube-mcp');
+    process.exit(1);
+  }
+
+  const server = new SonarQubeMCPServer(sonarUrl, sonarToken);
+  await server.start();
+}
+
+main().catch(console.error);

package/index.js

@@ -0,0 +1,327 @@
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} = require('@modelcontextprotocol/sdk/types.js');
+
+class SonarQubeMCPServer {
+  constructor(sonarUrl, sonarToken) {
+    this.sonarUrl = sonarUrl;
+    this.sonarToken = sonarToken;
+    this.server = new Server(
+      {
+        name: 'sonarqube-mcp-server',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.setupHandlers();
+  }
+
+  setupHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'get_sonar_rules',
+          description: 'Get SonarQube rules with pagination. Use multiple calls with different page numbers to get all rules and avoid character limits. Returns page info to guide next calls.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              language: {
+                type: 'string',
+                description: 'Programming language (java, javascript, python, etc.)',
+                default: 'java'
+              },
+              page: {
+                type: 'number',
+                description: 'Page number (1-based)',
+                default: 1
+              },
+              pageSize: {
+                type: 'number',
+                description: 'Number of rules per page (max 100)',
+                default: 50
+              },
+              projectKey: {
+                type: 'string',
+                description: 'SonarQube project key (optional)'
+              }
+            },
+            required: ['language']
+          }
+        },
+        {
+          name: 'get_quality_profile',
+          description: 'Get quality profile for a project',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              projectKey: {
+                type: 'string',
+                description: 'SonarQube project key'
+              }
+            },
+            required: ['projectKey']
+          }
+        },
+        {
+          name: 'get_project_issues',
+          description: 'Get issues for a project',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              projectKey: {
+                type: 'string',
+                description: 'SonarQube project key'
+              },
+              resolved: {
+                type: 'boolean',
+                description: 'Include resolved issues',
+                default: false
+              }
+            },
+            required: ['projectKey']
+          }
+        },
+        {
+          name: 'validate_code_rules',
+          description: 'Get rule violations for code validation',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              language: {
+                type: 'string',
+                description: 'Programming language',
+                default: 'java'
+              },
+              severity: {
+                type: 'string',
+                description: 'Minimum severity (INFO, MINOR, MAJOR, CRITICAL, BLOCKER)',
+                default: 'MAJOR'
+              }
+            },
+            required: ['language']
+          }
+        }
+      ]
+    }));
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        switch (name) {
+          case 'get_sonar_rules':
+            return await this.getSonarRulesPage(args.language, args.page || 1, args.pageSize || 50, args.projectKey);
+          
+          case 'get_quality_profile':
+            return await this.getQualityProfile(args.projectKey);
+          
+          case 'get_project_issues':
+            return await this.getProjectIssues(args.projectKey, args.resolved);
+          
+          case 'validate_code_rules':
+            return await this.getValidationRules(args.language, args.severity);
+          
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error: ${error.message}`
+            }
+          ]
+        };
+      }
+    });
+  }
+
+  async makeRequest(endpoint, params = {}) {
+    const url = new URL(`${this.sonarUrl}/api/${endpoint}`);
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== undefined) url.searchParams.append(key, value);
+    });
+
+    console.error(`Making request to: ${url.toString()}`);
+
+    const response = await fetch(url, {
+      headers: {
+        'Authorization': `Bearer ${this.sonarToken}`,
+        'Accept': 'application/json'
+      }
+    });
+
+    if (!response.ok) {
+      throw new Error(`SonarQube API error: ${response.status} ${response.statusText}`);
+    }
+
+    return await response.json();
+  }
+
+  async getQualityProfile(projectKey) {
+    const profile = await this.makeRequest('qualityprofiles/search', { project: projectKey });
+    
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(profile, null, 2)
+        }
+      ]
+    };
+  }
+
+  async getSonarRulesPage(language, page = 1, pageSize = 50, projectKey) {
+    const languageMap = {
+      'python': 'py',
+      'javascript': 'js', 
+      'typescript': 'ts',
+      'java': 'java',
+      'csharp': 'cs',
+      'cpp': 'cpp',
+      'c': 'c'
+    };
+    
+    const sonarLanguage = languageMap[language] || language;
+    const actualPageSize = Math.min(pageSize, 100);
+    
+    const params = {
+      activation: 'true',
+      languages: sonarLanguage,
+      ps: actualPageSize,
+      p: page
+    };
+
+    if (projectKey) {
+      const profile = await this.makeRequest('qualityprofiles/search', { project: projectKey });
+      if (profile.profiles?.length > 0) {
+        const langProfile = profile.profiles.find(p => p.language === sonarLanguage);
+        if (langProfile) {
+          params.qprofile = langProfile.key;
+        }
+      }
+    }
+
+    const rules = await this.makeRequest('rules/search', params);
+    const totalPages = Math.ceil(rules.total / actualPageSize);
+    
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            total: rules.total,
+            language: language,
+            projectKey: projectKey,
+            page: page,
+            pageSize: actualPageSize,
+            totalPages: totalPages,
+            hasMore: page < totalPages,
+            rules: rules.rules.map(rule => ({
+              key: rule.key,
+              name: rule.name,
+              severity: rule.severity,
+              type: rule.type,
+              tags: rule.tags
+            }))
+          }, null, 2)
+        }
+      ]
+    };
+  }
+
+  async getProjectIssues(projectKey, resolved = false) {
+    const issues = await this.makeRequest('issues/search', {
+      componentKeys: projectKey,
+      resolved: resolved.toString(),
+      ps: 100
+    });
+    
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            total: issues.total,
+            issues: issues.issues.map(issue => ({
+              key: issue.key,
+              rule: issue.rule,
+              severity: issue.severity,
+              component: issue.component,
+              line: issue.line,
+              message: issue.message,
+              status: issue.status,
+              type: issue.type
+            }))
+          }, null, 2)
+        }
+      ]
+    };
+  }
+
+  async getValidationRules(language, severity = 'MAJOR') {
+    const severityLevels = ['INFO', 'MINOR', 'MAJOR', 'CRITICAL', 'BLOCKER'];
+    const minSeverityIndex = severityLevels.indexOf(severity);
+    
+    // Mapear lenguajes a códigos de SonarQube
+    const languageMap = {
+      'python': 'py',
+      'javascript': 'js',
+      'typescript': 'ts',
+      'java': 'java',
+      'csharp': 'cs',
+      'cpp': 'cpp',
+      'c': 'c'
+    };
+    
+    const sonarLanguage = languageMap[language] || language;
+    
+    const rules = await this.makeRequest('rules/search', {
+      activation: 'true',
+      languages: sonarLanguage,
+      ps: 500
+    });
+
+    const filteredRules = rules.rules
+      .filter(rule => severityLevels.indexOf(rule.severity) >= minSeverityIndex)
+      .map(rule => ({
+        key: rule.key,
+        name: rule.name,
+        severity: rule.severity,
+        type: rule.type,
+        description: rule.htmlDesc || rule.mdDesc,
+        tags: rule.tags
+      }));
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            language: language,
+            minimumSeverity: severity,
+            totalRules: filteredRules.length,
+            rules: filteredRules
+          }, null, 2)
+        }
+      ]
+    };
+  }
+
+  async start() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('SonarQube MCP Server started');
+  }
+}
+
+module.exports = { SonarQubeMCPServer };

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@miocid152/sonarqube-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP Server for SonarQube integration",
+  "main": "index.js",
+  "bin": {
+    "sonarqube-mcp": "./bin/sonarqube-mcp.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["mcp", "sonarqube", "code-quality"],
+  "author": "Your Name",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.4.0",
+    "node-fetch": "^3.3.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "preferGlobal": true
+}