Hi-AI

Instructions

Implementation Reference

• src/tools/convention/analyzeComplexity.ts:174-282 (handler)

  Main handler function that analyzes code complexity for JS/TS/Python, computes cyclomatic, cognitive, Halstead metrics, and provides overall score.
  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-59 (schema)

  Tool schema definition including input schema for code and optional metrics.
  export const analyzeComplexityDefinition: ToolDefinition = { name: 'analyze_complexity', description: 'complexity|how complex|complexity|how complex|difficulty - 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'] } };
• src/index.ts:664-665 (registration)

  Tool registration in the main switch dispatcher that calls the analyzeComplexity handler.
  case 'analyze_complexity': return await analyzeComplexity(args as any) as CallToolResult;
• src/index.ts:140-140 (registration)

  Inclusion of tool definition in the tools array for listTools.
  analyzeComplexityDefinition,
• src/tools/convention/analyzeComplexity.ts:140-171 (helper)

  Helper function for Python-specific complexity analysis using PythonParser.
  async function analyzePythonComplexity(code: string): Promise<ToolResult> { try { const pythonComplexity = await PythonParser.analyzeComplexity(code); const totalComplexity = pythonComplexity.cyclomaticComplexity; const issues: string[] = []; const MAX_COMPLEXITY = 10; if (totalComplexity > MAX_COMPLEXITY) { issues.push('High complexity'); } pythonComplexity.functions.forEach(f => { if (f.complexity > MAX_COMPLEXITY) { issues.push(`Function ${f.name}: complexity ${f.complexity}`); } }); const issuesText = issues.length ? `\nIssues: ${issues.join(', ')}` : ''; return { content: [{ type: 'text', text: `Python Complexity: ${totalComplexity}\nFunctions: ${pythonComplexity.functions.length}\nClasses: ${pythonComplexity.classes.length}${issuesText}` }] }; } catch (error) { return { content: [{ type: 'text', text: `Python analysis error: ${error instanceof Error ? error.message : 'Unknown error'}` }] }; }