Hi-AI

Instructions

Implementation Reference

• src/tools/convention/analyzeComplexity.ts:178-286 (handler)

  Main handler function implementing the analyze_complexity tool. Handles JS/TS complexity analysis (cyclomatic, cognitive, Halstead) and delegates Python to PythonParser.

  export async function analyzeComplexity(args: { code: string; metrics?: string }): Promise<ToolResult> {
    const { code: complexityCode, metrics: complexityMetrics = 'all' } = args;
  
    // Check if this is Python code
    if (PythonParser.isPythonCode(complexityCode)) {
      return analyzePythonComplexity(complexityCode);
    }
  
    const complexityAnalysis = {
      action: 'analyze_complexity',
      metrics: complexityMetrics,
      results: {} as any,
      overallScore: 0,
      issues: [] as string[],
      recommendations: [] as string[],
      status: 'pending' as string
    };
  
    // AST 기반 cyclomatic complexity 분석
    complexityAnalysis.results.astCyclomaticComplexity = calculateAstComplexity(complexityCode);
    
    if (complexityMetrics === 'cyclomatic' || complexityMetrics === 'all') {
      const cyclomaticComplexityScore = (complexityCode.match(/\bif\b|\bfor\b|\bwhile\b|\bcase\b|\b&&\b|\b\|\|\b/g) || []).length + 1;
      complexityAnalysis.results.cyclomaticComplexity = {
        value: cyclomaticComplexityScore,
        threshold: CODE_QUALITY_METRICS.COMPLEXITY.maxCyclomaticComplexity,
        status: cyclomaticComplexityScore <= CODE_QUALITY_METRICS.COMPLEXITY.maxCyclomaticComplexity ? 'pass' : 'fail',
        description: 'Number of linearly independent paths through the code'
      };
    }
    
    if (complexityMetrics === 'cognitive' || complexityMetrics === 'all') {
      complexityAnalysis.results.cognitiveComplexity = calculateCognitiveComplexity(complexityCode);
    }
    
    if (complexityMetrics === 'halstead' || complexityMetrics === 'all') {
      // Halstead metrics calculation (simplified version)
      const operators = (complexityCode.match(/[+\-*/=<>!&|%^~?:]/g) || []).length;
      const operands = (complexityCode.match(/\b[a-zA-Z_]\w*\b/g) || []).length;
      const uniqueOperators = new Set(complexityCode.match(/[+\-*/=<>!&|%^~?:]/g) || []).size;
      const uniqueOperands = new Set(complexityCode.match(/\b[a-zA-Z_]\w*\b/g) || []).size;
      
      const vocabulary = uniqueOperators + uniqueOperands;
      const length = operators + operands;
      const calculatedLength = vocabulary > 0 ? uniqueOperators * Math.log2(uniqueOperators) + uniqueOperands * Math.log2(uniqueOperands) : 0;
      const volume = length * Math.log2(vocabulary);
      const difficulty = vocabulary > 0 ? (uniqueOperators / 2) * (operands / uniqueOperands) : 0;
      const effort = difficulty * volume;
      
      complexityAnalysis.results.halsteadMetrics = {
        vocabulary: vocabulary,
        length: length,
        calculatedLength: Math.round(calculatedLength),
        volume: Math.round(volume),
        difficulty: Math.round(difficulty * 100) / 100,
        effort: Math.round(effort),
        timeToProgram: Math.round(effort / 18), // Halstead's formula: effort / 18 seconds
        bugsDelivered: Math.round(volume / 3000 * 100) / 100, // Halstead's formula: volume / 3000
        description: 'Software science metrics measuring program complexity'
      };
    }
    
    // Additional complexity metrics
    if (complexityMetrics === 'all') {
      const lines = complexityCode.split('\n');
      const nonEmptyLines = lines.filter(line => line.trim().length > 0).length;
      const comments = (complexityCode.match(/\/\*[\s\S]*?\*\/|\/\/.*$/gm) || []).length;
      const functions = (complexityCode.match(/function\s+\w+|\w+\s*=\s*\(/g) || []).length;
      const classes = (complexityCode.match(/class\s+\w+/g) || []).length;
      
      complexityAnalysis.results.additionalMetrics = {
        linesOfCode: nonEmptyLines,
        comments: comments,
        commentRatio: nonEmptyLines > 0 ? Math.round((comments / nonEmptyLines) * 100) / 100 : 0,
        functions: functions,
        classes: classes,
        averageFunctionLength: functions > 0 ? Math.round(nonEmptyLines / functions) : 0
      };
    }
    
    // Overall assessment
    const issues = [];
    let overallScore = 100;
    
    if (complexityAnalysis.results.cyclomaticComplexity && complexityAnalysis.results.cyclomaticComplexity.status === 'fail') {
      issues.push('High cyclomatic complexity detected');
      overallScore -= 20;
    }
    
    if (complexityAnalysis.results.cognitiveComplexity && complexityAnalysis.results.cognitiveComplexity.status === 'fail') {
      issues.push('High cognitive complexity detected');
      overallScore -= 25;
    }
    
    if (complexityAnalysis.results.halsteadMetrics && complexityAnalysis.results.halsteadMetrics.difficulty > 10) {
      issues.push('High Halstead difficulty detected');
      overallScore -= 15;
    }
    
    complexityAnalysis.overallScore = Math.max(0, overallScore);
    complexityAnalysis.issues = issues;
  
    return {
      content: [{
        type: 'text',
        text: `Complexity: ${complexityAnalysis.results.astCyclomaticComplexity?.value ?? 'N/A'}\nScore: ${complexityAnalysis.overallScore}${issues.length ? '\nIssues: ' + issues.join(', ') : ''}`
      }]
    };
  }

• src/tools/convention/analyzeComplexity.ts:44-63 (schema)

  Input schema and ToolDefinition for the analyze_complexity tool.

  export const analyzeComplexityDefinition: ToolDefinition = {
    name: 'analyze_complexity',
    description: '복잡도|복잡한지|complexity|how complex|난이도 - Analyze code complexity',
    inputSchema: {
      type: 'object',
      properties: {
        code: { type: 'string', description: 'Code to analyze' },
        metrics: { type: 'string', description: 'Metrics to calculate', enum: ['cyclomatic', 'cognitive', 'halstead', 'all'] }
      },
      required: ['code']
    },
    annotations: {
      title: 'Analyze Complexity',
      audience: ['user', 'assistant'],
      readOnlyHint: true,
      destructiveHint: false,
      idempotentHint: true,
      openWorldHint: false
    }
  };

• src/index.ts:183-188 (registration)

  Registration of the analyze_complexity handler in the toolHandlers dispatch map.

  'get_coding_guide': getCodingGuide,
  'apply_quality_rules': applyQualityRules,
  'validate_code_quality': validateCodeQuality,
  'analyze_complexity': analyzeComplexity,
  'check_coupling_cohesion': checkCouplingCohesion,
  'suggest_improvements': suggestImprovements,

• src/index.ts:119-124 (registration)

  Registration of the analyzeComplexityDefinition in the tools list for MCP listTools endpoint.

  applyQualityRulesDefinition,
  validateCodeQualityDefinition,
  analyzeComplexityDefinition,
  checkCouplingCohesionDefinition,
  suggestImprovementsDefinition,

• src/lib/PythonParser.ts:283-290 (helper)

  Helper method in PythonParser used for Python code complexity analysis, called from the main handler.

  public static async analyzeComplexity(code: string): Promise<PythonComplexity> {
    const result = await this.executePython(code, 'complexity');
    return {
      cyclomaticComplexity: result.cyclomaticComplexity || 1,
      functions: result.functions || [],
      classes: result.classes || []
    };
  }