analyze_code_quality

Instructions

Implementation Reference

• src/index.ts:289-317 (handler)

  The handleQualityAnalysis method is the primary handler for the 'analyze_code_quality' tool. It validates input, performs code analysis using PythonAnalyzer, applies user-specified filters for style and maintainability checks, generates a custom quality report, and returns the result as MCP content.

  private async handleQualityAnalysis(args: unknown) {
    const { code, filename, includeStyle, includeMaintainability } = QualityAnalysisSchema.parse(args);
    
    const result = this.analyzer.analyzePythonCode(code, filename);
    
    // Filter issues based on options
    let filteredIssues = result.issues;
    
    if (!includeStyle) {
      filteredIssues = filteredIssues.filter(issue => 
        issue.type !== 'style' && !issue.rule.includes('naming-convention')
      );
    }
    
    if (!includeMaintainability) {
      filteredIssues = filteredIssues.filter(issue => issue.type !== 'maintainability');
    }
    
    const filteredResult = { ...result, issues: filteredIssues, totalIssues: filteredIssues.length };
    const qualityReport = this.generateQualityReport(filteredResult);
    
    return {
      content: [
        {
          type: 'text',
          text: qualityReport
        }
      ]
    };

• src/index.ts:37-42 (schema)

  Zod validation schema for the analyze_code_quality tool input parameters, defining code, filename, includeStyle, and includeMaintainability fields.

  const QualityAnalysisSchema = z.object({
    code: z.string().min(1, "Code cannot be empty"),
    filename: z.string().optional().default("unknown.py"),
    includeStyle: z.boolean().optional().default(true),
    includeMaintainability: z.boolean().optional().default(true)
  });

• src/index.ts:125-153 (registration)

  Tool registration in the ListTools response, defining the name, description, and JSON schema for input validation of analyze_code_quality.

  {
    name: 'analyze_code_quality',
    description: 'Deep code quality analysis including style, maintainability, performance, and best practices compliance.',
    inputSchema: {
      type: 'object',
      properties: {
        code: {
          type: 'string',
          description: 'Python code to analyze for quality issues'
        },
        filename: {
          type: 'string',
          description: 'Name of the file (optional)',
          default: 'unknown.py'
        },
        includeStyle: {
          type: 'boolean',
          description: 'Include style and naming convention checks',
          default: true
        },
        includeMaintainability: {
          type: 'boolean',
          description: 'Include maintainability and documentation checks',
          default: true
        }
      },
      required: ['code']
    }
  },

• src/python-analyzer.ts:112-195 (helper)

  Core analysis engine called by the tool handler. Uses regex patterns to detect security vulnerabilities, quality issues, style violations, and maintainability problems in Python code, computes quality and security scores, and produces structured AnalysisResult.

  public analyzePythonCode(code: string, fileName: string = 'unknown.py'): AnalysisResult {
    const lines = code.split('\n');
    const issues: CodeIssue[] = [];
    
    // Analyze each line
    lines.forEach((line, index) => {
      const lineNumber = index + 1;
      
      // Check security patterns
      this.securityPatterns.forEach(pattern => {
        if (pattern.pattern.test(line)) {
          issues.push({
            type: 'security',
            severity: pattern.severity,
            line: lineNumber,
            message: pattern.message,
            rule: pattern.rule,
            codeSnippet: line.trim(),
            suggestion: this.getSuggestion(pattern.rule, line)
          });
        }
      });
      
      // Check quality patterns
      this.qualityPatterns.forEach(pattern => {
        if (pattern.pattern.test(line)) {
          issues.push({
            type: 'quality',
            severity: pattern.severity,
            line: lineNumber,
            message: pattern.message,
            rule: pattern.rule,
            codeSnippet: line.trim(),
            suggestion: this.getSuggestion(pattern.rule, line)
          });
        }
      });
      
      // Check maintainability patterns
      this.maintainabilityPatterns.forEach(pattern => {
        if (pattern.pattern.test(line)) {
          issues.push({
            type: 'maintainability',
            severity: pattern.severity,
            line: lineNumber,
            message: pattern.message,
            rule: pattern.rule,
            codeSnippet: line.trim(),
            suggestion: this.getSuggestion(pattern.rule, line)
          });
        }
      });
    });
  
    // Multi-line analysis
    this.analyzeMultilinePatterns(code, issues);
    
    // Calculate metrics
    const criticalIssues = issues.filter(i => i.severity === 'critical').length;
    const highIssues = issues.filter(i => i.severity === 'high').length;
    const mediumIssues = issues.filter(i => i.severity === 'medium').length;
    const lowIssues = issues.filter(i => i.severity === 'low').length;
    
    const codeQualityScore = this.calculateCodeQualityScore(issues, lines.length);
    const securityScore = this.calculateSecurityScore(issues);
    
    return {
      fileName,
      totalLines: lines.length,
      totalIssues: issues.length,
      criticalIssues,
      highIssues,
      mediumIssues,
      lowIssues,
      issues: issues.sort((a, b) => {
        const severityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
        return severityOrder[b.severity] - severityOrder[a.severity] || a.line - b.line;
      }),
      summary: this.generateSummary(issues, lines.length),
      recommendations: this.generateRecommendations(issues),
      codeQualityScore,
      securityScore
    };
  }

• src/index.ts:393-406 (helper)

  Helper method that formats the quality analysis report specific to the analyze_code_quality tool, including header, quality score, breakdown, and recommendations.

  private generateQualityReport(result: AnalysisResult): string {
    const sections = [
      '📊 **CODE QUALITY ANALYSIS REPORT**',
      '=' + '='.repeat(50),
      `**File:** ${result.fileName}`,
      `**Quality Score:** ${result.codeQualityScore}/100 ${this.getQualityRating(result.codeQualityScore)}`,
      '',
      this.generateQualityBreakdown(result),
      '',
      this.generateQualityRecommendations(result)
    ];
  
    return sections.join('\n');
  }