sonar-autofix 0.0.5

package/packages/sonar-client/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/packages/sonar-client/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"
+  }
+}

package/packages/validator/index.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+
+const execAsync = promisify(exec);
+
+const DEFAULT_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+
+class Validator {
+  /**
+   * @param {object} config
+   * @param {object} config.validation
+   * @param {string[]} config.validation.build - Build commands to run
+   * @param {string[]} config.validation.lint - Lint commands to run
+   * @param {string[]} config.validation.tests - Test commands to run
+   * @param {string} [cwd] - Working directory for commands
+   */
+  constructor(config = {}, cwd = process.cwd()) {
+    const validation = config.validation || {};
+    this.commands = {
+      build: validation.build || ['npm run build'],
+      lint: validation.lint || ['npm run lint'],
+      tests: validation.tests || ['npm test'],
+    };
+    this.cwd = cwd;
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+  }
+
+  /**
+   * Run a single shell command.
+   * @param {string} command
+   * @returns {Promise<{success: boolean, stdout: string, stderr: string, exitCode: number}>}
+   */
+  async runCommand(command) {
+    console.log(`[Validator] Running: ${command} (cwd: ${this.cwd})`);
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: this.cwd,
+        timeout: this.timeout,
+        maxBuffer: 10 * 1024 * 1024, // 10 MB
+      });
+      return { success: true, stdout: stdout || '', stderr: stderr || '', exitCode: 0 };
+    } catch (err) {
+      return {
+        success: false,
+        stdout: err.stdout || '',
+        stderr: err.stderr || err.message || '',
+        exitCode: err.code != null ? err.code : 1,
+      };
+    }
+  }
+
+  /**
+   * Run a list of commands sequentially.
+   * @param {string[]} commands
+   * @returns {Promise<{success: boolean, output: string, errors: string[]}>}
+   */
+  async _runCommands(commands) {
+    const outputs = [];
+    const errors = [];
+    let success = true;
+
+    for (const cmd of commands) {
+      const result = await this.runCommand(cmd);
+      if (result.stdout) outputs.push(result.stdout);
+      if (!result.success) {
+        success = false;
+        errors.push(result.stderr || `Command failed: ${cmd}`);
+      }
+    }
+
+    return { success, output: outputs.join('\n'), errors };
+  }
+
+  /**
+   * Run per-file validation using the project's configured build commands.
+   * Instead of running individual tool checks on a single file (which ignores
+   * tsconfig.json, path aliases, etc.), we run the project's own build/lint
+   * commands so validation matches the real project setup.
+   * @param {string} filePath
+   * @returns {Promise<{success: boolean, errors: string[]}>}
+   */
+  async validateFile(filePath) {
+    console.log(`[Validator] Validating after changes to: ${filePath}`);
+    const errors = [];
+    let success = true;
+
+    // Run build commands — these respect tsconfig.json, path aliases, etc.
+    for (const cmd of this.commands.build) {
+      const result = await this.runCommand(cmd);
+      if (!result.success) {
+        success = false;
+        errors.push(result.stderr || result.stdout || `Build failed: ${cmd}`);
+      }
+    }
+
+    // Run lint commands
+    for (const cmd of this.commands.lint) {
+      const result = await this.runCommand(cmd);
+      if (!result.success) {
+        success = false;
+        errors.push(result.stderr || result.stdout || `Lint failed: ${cmd}`);
+      }
+    }
+
+    return { success, errors };
+  }
+
+  /**
+   * Run all configured build commands sequentially.
+   * @returns {Promise<{success: boolean, output: string, errors: string[]}>}
+   */
+  async runBuild() {
+    console.log('[Validator] Running build commands...');
+    return this._runCommands(this.commands.build);
+  }
+
+  /**
+   * Run all configured lint commands.
+   * @returns {Promise<{success: boolean, output: string, errors: string[]}>}
+   */
+  async runLint() {
+    console.log('[Validator] Running lint commands...');
+    return this._runCommands(this.commands.lint);
+  }
+
+  /**
+   * Run all configured test commands.
+   * @returns {Promise<{success: boolean, output: string, errors: string[]}>}
+   */
+  async runTests() {
+    console.log('[Validator] Running test commands...');
+    return this._runCommands(this.commands.tests);
+  }
+
+  /**
+   * Run build, lint, and tests in sequence.
+   * @returns {Promise<{success: boolean, results: {build: object, lint: object, tests: object}}>}
+   */
+  async validateAll() {
+    console.log('[Validator] Running full validation...');
+    const build = await this.runBuild();
+    const lint = await this.runLint();
+    const tests = await this.runTests();
+
+    return {
+      success: build.success && lint.success && tests.success,
+      results: { build, lint, tests },
+    };
+  }
+
+  /**
+   * Run per-batch validations (build + tests).
+   * @returns {Promise<{success: boolean, results: {build: object, tests: object}}>}
+   */
+  async validateBatch() {
+    console.log('[Validator] Running batch validation (build + tests)...');
+    const build = await this.runBuild();
+    const tests = await this.runTests();
+
+    return {
+      success: build.success && tests.success,
+      results: { build, tests },
+    };
+  }
+}
+
+module.exports = Validator;

package/packages/validator/package.json

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

package/prompts/fix-issues.md

@@ -0,0 +1,51 @@
+You are an expert software engineer tasked with fixing code quality issues identified by SonarQube/SonarCloud.
+
+## Instructions
+
+You will be given:
+1. The full contents of a source file
+2. A list of issues found by Sonar analysis, each with a rule, severity, message, and line number
+
+Your task is to fix ALL the listed issues in the file while following these rules:
+
+- Modify only the supplied file.
+- Do not rename public APIs.
+- Preserve formatting and code style.
+- Do not introduce unrelated changes.
+- Return the complete file content with all fixes applied.
+- If an issue cannot be safely fixed without risking breaking changes, leave it as-is and add a comment explaining why.
+
+## File
+
+**Path:** {{filePath}}
+
+```
+{{fileContent}}
+```
+
+## Issues to Fix
+
+{{#each issues}}
+### Issue {{@index}}
+- **Rule:** {{this.rule}}
+- **Severity:** {{this.severity}}
+- **Type:** {{this.type}}
+- **Message:** {{this.message}}
+- **Line:** {{this.line}}
+{{/each}}
+
+{{#if codingGuidelines}}
+## Coding Guidelines
+
+{{codingGuidelines}}
+{{/if}}
+
+{{#if projectInstructions}}
+## Project Instructions
+
+{{projectInstructions}}
+{{/if}}
+
+## Response Format
+
+Return ONLY the complete fixed file content, wrapped in a code block with the appropriate language identifier. Do not include any explanations before or after the code block.

package/prompts/retry-fix.md

@@ -0,0 +1,42 @@
+You are an expert software engineer. A previous attempt to fix code quality issues failed validation.
+
+## Instructions
+
+Your previous fix attempt caused the following validation errors. Please fix the file again, addressing both the original Sonar issues AND the validation errors.
+
+Rules:
+- Modify only the supplied file.
+- Do not rename public APIs.
+- Preserve formatting and code style.
+- Do not introduce unrelated changes.
+- Return the complete file content with all fixes applied.
+- Pay special attention to the validation errors — these must be resolved.
+
+## File
+
+**Path:** {{filePath}}
+
+```
+{{fileContent}}
+```
+
+## Original Sonar Issues
+
+{{#each issues}}
+### Issue {{@index}}
+- **Rule:** {{this.rule}}
+- **Severity:** {{this.severity}}
+- **Type:** {{this.type}}
+- **Message:** {{this.message}}
+- **Line:** {{this.line}}
+{{/each}}
+
+## Validation Errors from Previous Attempt
+
+```
+{{validationErrors}}
+```
+
+## Response Format
+
+Return ONLY the complete fixed file content, wrapped in a code block with the appropriate language identifier. Do not include any explanations before or after the code block.