@sonar-autofix/sonar-client 0.0.1

package/index.js

@@ -0,0 +1,327 @@
+// sonarclient.js
+const axios = require('axios');
+const { exec } = require('node:child_process');
+const { promisify } = require('node:util');
+const execAsync = promisify(exec);
+
+class SonarClient {
+  constructor(config) {
+    this.baseUrl = config.sonar?.host || config.baseUrl || 'http://localhost:9000';
+    this.token = config.sonar?.token || config.token;
+    this.axiosInstance = axios.create({
+      baseURL: this.baseUrl,
+      headers: {
+        'Authorization': `Bearer ${this.token}`,
+        'Content-Type': 'application/json'
+      }
+    });
+  }
+
+  // Get project analysis
+  async getAnalysis(projectKey) {
+    try {
+      const response = await this.axiosInstance.get(`/api/qualitygates/project_status?projectKey=${projectKey}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`Failed to get analysis: ${error.message}`);
+    }
+  }
+
+  // Get issues for a project - Updated to use proper endpoint
+  async getIssues(projectKey, severity) {
+    if (!projectKey) {
+      throw new Error('projectKey is required to fetch issues');
+    }
+    try {
+      var params = {
+        componentKeys: projectKey,
+        statuses: 'OPEN,CONFIRMED,REOPENED'
+      };
+      if (severity) {
+        params.severities = severity;
+      }
+      const response = await this.axiosInstance.get(`/api/issues/search`, {
+        params: params
+      });
+      return response.data;
+    } catch (error) {
+      // Provide more detailed error information for debugging
+      if (error.response) {
+        throw new Error(`Failed to get issues: ${error.message} - Status: ${error.response.status}, Data: ${JSON.stringify(error.response.data)}`);
+      } else {
+        throw new Error(`Failed to get issues: ${error.message}`);
+      }
+    }
+  }
+
+  // Get quality gate status - Updated endpoint
+  async getQualityGate(projectKey) {
+    try {
+      const response = await this.axiosInstance.get(`/api/qualitygates/project_status?projectKey=${projectKey}`);
+      return response.data;
+    } catch (error) {
+      // If the quality gate endpoint fails, try a different one
+      if (error.response && error.response.status === 404) {
+        console.log('Quality gate endpoint not available, trying alternative API');
+        // Try to get project info as fallback
+        const response = await this.axiosInstance.get(`/api/projects/search?projects=${projectKey}`);
+        return response.data;
+      }
+      throw new Error(`Failed to get quality gate: ${error.message}`);
+    }
+  }
+
+  // Get project information (fallback for quality gate)
+  async getProjectInfo(projectKey) {
+    try {
+      const response = await this.axiosInstance.get(`/api/projects/search?projects=${projectKey}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`Failed to get project info: ${error.message}`);
+    }
+  }
+
+  // Get project branches
+  async getProjectBranches(projectKey) {
+    try {
+      const response = await this.axiosInstance.get(`/api/project_branches/list?project=${projectKey}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`Failed to get project branches: ${error.message}`);
+    }
+  }
+
+  // Get project pull requests
+  async getProjectPullRequests(projectKey) {
+    try {
+      const response = await this.axiosInstance.get(`/api/pull_requests/list?project=${projectKey}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`Failed to get project pull requests: ${error.message}`);
+    }
+  }
+
+  // Get project issues by file
+  async getIssuesByFile(projectKey, fileKey) {
+    try {
+      const response = await this.axiosInstance.get(`/api/issues/search?projectKeys=${projectKey}&fileUuids=${fileKey}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`Failed to get issues by file: ${error.message}`);
+    }
+  }
+
+  // Get project issues by component
+  async getIssuesByComponent(projectKey, componentKey) {
+    try {
+      const response = await this.axiosInstance.get(`/api/issues/search?projectKeys=${projectKey}&componentKeys=${componentKey}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`Failed to get issues by component: ${error.message}`);
+    }
+  }
+
+  // Get project status (more reliable endpoint)
+  async getProjectStatus(projectKey) {
+    try {
+      const response = await this.axiosInstance.get(`/api/projects/search?projects=${projectKey}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`Failed to get project status: ${error.message}`);
+    }
+  }
+
+  // Get project metrics
+  async getProjectMetrics(projectKey, metricKeys) {
+    try {
+      const response = await this.axiosInstance.get(`/api/measures/component?component=${projectKey}&metricKeys=${metricKeys.join(',')}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`Failed to get project metrics: ${error.message}`);
+    }
+  }
+
+  // Get project issues by component (with proper error handling)
+  async getIssuesByComponentKey(projectKey, componentKey) {
+    try {
+      const response = await this.axiosInstance.get(`/api/issues/search?projectKeys=${projectKey}&componentKeys=${componentKey}`);
+      return response.data;
+    } catch (error) {
+      // If component key search fails, try with project key only
+      if (error.response && error.response.status === 400) {
+        console.log('Component search failed, falling back to project search');
+        const response = await this.axiosInstance.get(`/api/issues/search?projectKeys=${projectKey}`);
+        return response.data;
+      }
+      throw new Error(`Failed to get issues by component key: ${error.message}`);
+    }
+  }
+
+  // Get project issues by file (with proper error handling)
+  async getIssuesByFileKey(projectKey, fileKey) {
+    try {
+      const response = await this.axiosInstance.get(`/api/issues/search?projectKeys=${projectKey}&fileUuids=${fileKey}`);
+      return response.data;
+    } catch (error) {
+      // If file search fails, try with project key only
+      if (error.response && error.response.status === 400) {
+        console.log('File search failed, falling back to project search');
+        const response = await this.axiosInstance.get(`/api/issues/search?projectKeys=${projectKey}`);
+        return response.data;
+      }
+      throw new Error(`Failed to get issues by file key: ${error.message}`);
+    }
+  }
+
+  // Enhanced project information with MCP integration capability
+  async getEnhancedProjectInfo(projectKey) {
+    try {
+      // First, try to get project info
+      const projectInfo = await this.getProjectInfo(projectKey);
+
+      // Then try to get metrics if available
+      let metrics = null;
+      try {
+        metrics = await this.getProjectMetrics(projectKey, ['ncloc', 'bugs', 'vulnerabilities']);
+      } catch (metricsError) {
+        console.log('Metrics not available:', metricsError.message);
+      }
+
+      // Then try to get branches if available
+      let branches = null;
+      try {
+        branches = await this.getProjectBranches(projectKey);
+      } catch (branchesError) {
+        console.log('Branches not available:', branchesError.message);
+      }
+
+      // Then try to get pull requests if available
+      let pullRequests = null;
+      try {
+        pullRequests = await this.getProjectPullRequests(projectKey);
+      } catch (prError) {
+        console.log('Pull requests not available:', prError.message);
+      }
+
+      return {
+        projectInfo,
+        metrics,
+        branches,
+        pullRequests
+      };
+    } catch (error) {
+      throw new Error(`Failed to get enhanced project info: ${error.message}`);
+    }
+  }
+
+  // MCP Server integration methods
+  // async getMCPProjectInfo(projectKey) {
+  //   try {
+  //     // This method is specifically designed to work with the SonarQube MCP server
+  //     const projectInfo = await this.getProjectInfo(projectKey);
+  //
+  //     // Try to use the MCP server's enhanced capabilities
+  //     try {
+  //       const mcpInfo = await this.getEnhancedProjectInfo(projectKey);
+  //       return {
+  //         ...mcpInfo,
+  //         source: 'sonarqube_mcp'
+  //       };
+  //     } catch (mcpError) {
+  //       console.log('MCP integration not available, returning basic project info');
+  //       return {
+  //         projectInfo,
+  //         source: 'sonarqube_basic'
+  //       };
+  //     }
+  //   } catch (error) {
+  //     throw new Error(`Failed to get MCP project info: ${error.message}`);
+  //   }
+  // }
+
+  // Method to check if MCP server is available and working
+  // async testMCPConnection() {
+  //   try {
+  //     // Test basic project search to verify connection
+  //     const response = await this.axiosInstance.get(`/api/projects/search?projects=test`);
+  //     return {
+  //       connected: true,
+  //       status: 'MCP server is accessible',
+  //       response: response.data
+  //     };
+  //   } catch (error) {
+  //     return {
+  //       connected: false,
+  //       status: `MCP server connection failed: ${error.message}`,
+  //       error: error.message
+  //     };
+  //   }
+  // }
+
+  // Method to list projects using MCP server if available
+  async listProjects(query = '') {
+    try {
+      // First attempt to use MCP server's search function if available
+      const response = await this.axiosInstance.get(`/api/projects/search?q=${query}`);
+      return response.data;
+    } catch (error) {
+      // Fallback to basic project search
+      console.log('MCP search not available, using fallback');
+      const response = await this.axiosInstance.get(`/api/projects/search?projects=${query}`);
+      return response.data;
+    }
+  }
+
+  // Run sonar-scanner analysis
+  async runAnalysis(projectKey) {
+    try {
+      const { stdout } = await execAsync(
+        `npx sonar-scanner -Dsonar.projectKey=${projectKey} -Dsonar.host.url=${this.baseUrl} -Dsonar.token=${this.token}`
+      );
+      return { success: true, output: stdout };
+    } catch (error) {
+      return { success: false, output: error.message };
+    }
+  }
+
+  // Wait for quality gate result by polling task status
+  async waitForQualityGate(projectKey, taskId, maxWaitMs = 120000) {
+    const pollInterval = 5000;
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < maxWaitMs) {
+      const response = await this.axiosInstance.get(`/api/ce/task?id=${taskId}`);
+      const status = response.data.task.status;
+
+      if (['SUCCESS', 'FAILED', 'CANCELED'].includes(status)) {
+        return this.getQualityGate(projectKey);
+      }
+
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+
+    throw new Error(`Quality gate timeout after ${maxWaitMs}ms`);
+  }
+
+  // Get security hotspots for a project
+  async getHotspots(projectKey) {
+    try {
+      const response = await this.axiosInstance.get(`/api/hotspots/search?projectKey=${projectKey}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`Failed to get hotspots: ${error.message}`);
+    }
+  }
+
+  // Get raw source code for a component
+  async getSourceCode(componentKey) {
+    try {
+      const response = await this.axiosInstance.get(`/api/sources/raw?key=${componentKey}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`Failed to get source code: ${error.message}`);
+    }
+  }
+}
+
+module.exports = SonarClient;

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@sonar-autofix/sonar-client",
+  "version": "0.0.1",
+  "description": "Sonar client for the Sonar Autofix tool",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "sonar",
+    "autofix",
+    "github",
+    "client"
+  ],
+  "author": "Sonar Autofix Team",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.19.0"
+  }
+}