validate_code_quality

Analyze code quality by checking complexity, coupling, cohesion, maintainability, and performance metrics to identify improvement areas.

Instructions

Input Schema

TableJSON Schema

Name	Required	Description
`code`	Yes	Code to validate
`type`	No	Code type
`strict`	No	Apply strict validation rules
`metrics`	No	Specific metrics to check

Implementation Reference

src/tools/convention/validateCodeQuality.ts:59-201 (handler)

The main handler function that performs code quality validation including complexity analysis, anti-pattern detection, error handling checks, and performance suggestions for different code types. Computes a quality score and returns structured issues and recommendations.

export async function validateCodeQuality(args: { code: string; type?: string; strict?: boolean; metrics?: string }): Promise<ToolResult> {
  const { code: validateCode, type: validateType = 'general', strict = false, metrics = 'all' } = args;
  
  const qualityIssues = [];
  const qualityScore = { total: 100, deductions: [] as Array<{reason: string, points: number}> };
  
  // Basic complexity checks
  const lines = validateCode.split('\n');
  const functionLineCount = lines.length;
  
  if (functionLineCount > CODE_QUALITY_METRICS.COMPLEXITY.maxFunctionLines) {
    qualityIssues.push({
      type: 'complexity',
      severity: 'high',
      message: `Function exceeds maximum lines (${functionLineCount}/${CODE_QUALITY_METRICS.COMPLEXITY.maxFunctionLines})`
    });
    qualityScore.deductions.push({ reason: 'Function too long', points: 15 });
  }
  
  // Nesting depth check
  let maxNesting = 0;
  let currentNesting = 0;
  for (const line of lines) {
    const braceCount = (line.match(/\{/g) || []).length - (line.match(/\}/g) || []).length;
    currentNesting += braceCount;
    maxNesting = Math.max(maxNesting, currentNesting);
  }
  
  if (maxNesting > CODE_QUALITY_METRICS.COMPLEXITY.maxNestingDepth) {
    qualityIssues.push({
      type: 'complexity',
      severity: 'medium',
      message: `Nesting depth exceeds maximum (${maxNesting}/${CODE_QUALITY_METRICS.COMPLEXITY.maxNestingDepth})`
    });
    qualityScore.deductions.push({ reason: 'Deep nesting', points: 10 });
  }
  
  // Cyclomatic complexity estimation
  const cyclomaticComplexity = (validateCode.match(/\bif\b|\bfor\b|\bwhile\b|\bcase\b|\b&&\b|\b\|\|\b/g) || []).length + 1;
  if (cyclomaticComplexity > CODE_QUALITY_METRICS.COMPLEXITY.maxCyclomaticComplexity) {
    qualityIssues.push({
      type: 'complexity',
      severity: 'high',
      message: `Cyclomatic complexity too high (${cyclomaticComplexity}/${CODE_QUALITY_METRICS.COMPLEXITY.maxCyclomaticComplexity})`
    });
    qualityScore.deductions.push({ reason: 'High cyclomatic complexity', points: 20 });
  }
  
  // Anti-pattern checks
  if (validateCode.includes('any')) {
    qualityIssues.push({
      type: 'type-safety',
      severity: 'medium',
      message: 'Using "any" type - consider more specific types'
    });
    qualityScore.deductions.push({ reason: 'Any type usage', points: 10 });
  }
  
  if (validateCode.includes('== ')) {
    qualityIssues.push({
      type: 'best-practices',
      severity: 'low',
      message: 'Use strict equality (===) instead of loose equality (==)'
    });
    qualityScore.deductions.push({ reason: 'Loose equality', points: 5 });
  }
  
  if (validateCode.includes('var ')) {
    qualityIssues.push({
      type: 'best-practices',
      severity: 'medium',
      message: 'Use const/let instead of var'
    });
    qualityScore.deductions.push({ reason: 'Var usage', points: 8 });
  }
  
  // Magic numbers check
  const magicNumbers = validateCode.match(/\b\d{2,}\b/g) || [];
  if (magicNumbers.length > 0) {
    qualityIssues.push({
      type: 'maintainability',
      severity: 'low',
      message: `Found potential magic numbers: ${magicNumbers.join(', ')}`
    });
    qualityScore.deductions.push({ reason: 'Magic numbers', points: 5 });
  }
  
  // Error handling check
  const hasErrorHandling = validateCode.includes('try') || validateCode.includes('catch') || validateCode.includes('throw');
  if (!hasErrorHandling && validateCode.includes('async')) {
    qualityIssues.push({
      type: 'error-handling',
      severity: 'medium',
      message: 'Async functions should include error handling'
    });
    qualityScore.deductions.push({ reason: 'Missing error handling', points: 10 });
  }
  
  // Performance checks for React components
  if (validateType === 'component' && validateCode.includes('React')) {
    if (!validateCode.includes('memo') && !validateCode.includes('useMemo') && !validateCode.includes('useCallback')) {
      qualityIssues.push({
        type: 'performance',
        severity: 'low',
        message: 'Consider using React.memo, useMemo, or useCallback for performance optimization'
      });
      qualityScore.deductions.push({ reason: 'Missing performance optimization', points: 5 });
    }
  }
  
  const finalScore = Math.max(0, qualityScore.total - qualityScore.deductions.reduce((sum, d) => sum + d.points, 0));
  
  const validationResult = {
    action: 'validate_code_quality',
    type: validateType,
    strict,
    metricsRequested: metrics,
    score: finalScore,
    grade: finalScore >= 90 ? 'A' : finalScore >= 80 ? 'B' : finalScore >= 70 ? 'C' : finalScore >= 60 ? 'D' : 'F',
    issues: qualityIssues,
    deductions: qualityScore.deductions,
    recommendations: qualityIssues.length > 0 ? [
      'Consider breaking down complex functions',
      'Reduce nesting depth with early returns',
      'Use more specific types instead of "any"',
      'Apply consistent coding standards',
      'Add proper error handling',
      'Consider performance optimizations'
    ] : ['Code quality is excellent!'],
    metrics: {
      complexity: cyclomaticComplexity,
      lines: functionLineCount,
      nesting: maxNesting,
      issues: qualityIssues.length
    },
    status: 'success'
  };
  
  const topIssues = qualityIssues.slice(0, 8);
  return {
    content: [{ type: 'text', text: `Type: ${validateType}\nScore: ${finalScore}/100 (Grade: ${validationResult.grade})\nMetrics: Lines=${validationResult.metrics.lines}, Complexity=${validationResult.metrics.complexity}, Nesting=${validationResult.metrics.nesting}\n\nIssues (${qualityIssues.length}):\n${topIssues.map(i => `[${i.severity.toUpperCase()}] ${i.type}: ${i.message}`).join('\n')}${qualityIssues.length > 8 ? `\n... ${qualityIssues.length - 8} more issues` : ''}\n\nDeductions: -${qualityScore.deductions.reduce((sum, d) => sum + d.points, 0)} pts (${qualityScore.deductions.map(d => `${d.reason}: -${d.points}`).join(', ')})` }]
  };
}

src/tools/convention/validateCodeQuality.ts:36-57 (schema)

The ToolDefinition object defining the input schema, description, and annotations for the validate_code_quality tool.

export const validateCodeQualityDefinition: ToolDefinition = {
  name: 'validate_code_quality',
  description: '품질|리뷰|검사|quality|review code|check quality|validate|코드 리뷰 - Validate code quality',
  inputSchema: {
    type: 'object',
    properties: {
      code: { type: 'string', description: 'Code to validate' },
      type: { type: 'string', description: 'Code type', enum: ['component', 'function', 'hook', 'utility', 'general'] },
      strict: { type: 'boolean', description: 'Apply strict validation rules' },
      metrics: { type: 'string', description: 'Specific metrics to check', enum: ['complexity', 'coupling', 'cohesion', 'maintainability', 'performance', 'all'] }
    },
    required: ['code']
  },
  annotations: {
    title: 'Validate Code Quality',
    audience: ['user', 'assistant'],
    readOnlyHint: true,
    destructiveHint: false,
    idempotentHint: true,
    openWorldHint: false
  }
};

src/index.ts:61-61 (registration)

Import statement bringing in the tool definition and handler function.

import { validateCodeQualityDefinition, validateCodeQuality } from './tools/convention/validateCodeQuality.js';

src/index.ts:120-120 (registration)
Registration of the tool definition in the main tools array used for ListTools.
```
validateCodeQualityDefinition,
```
src/index.ts:185-185 (registration)
Registration of the handler in the toolHandlers object for dynamic dispatch during tool calls.
```
'validate_code_quality': validateCodeQuality,
```

Hi-AI