Development Tools MCP Server

Instructions

Implementation Reference

• src/tools/code-quality.ts:182-198 (handler)

  Handler function block for the 'analyze_code_quality' tool. Processes arguments, reads files using FileReader, calls CodeAnalyzer.analyzeCodeQuality, and returns formatted metrics.

  case 'analyze_code_quality': {
    const files = params.files as string[];
    const options: CodeAnalysisOptions = {
      includePatterns: params.includePatterns as string[],
      excludePatterns: params.excludePatterns as string[],
      maxComplexity: params.maxComplexity as number,
      checkDuplicates: params.checkDuplicates as boolean,
      checkCodeSmells: params.checkCodeSmells as boolean,
    };
  
    const codeFiles = await FileReader.readFiles(files.join(','), {
      ignore: options.excludePatterns,
    });
  
    const metrics = await codeAnalyzer.analyzeCodeQuality(codeFiles, options);
    return Formatters.formatCodeQualityMetrics(metrics);
  }

• src/tools/code-quality.ts:12-46 (schema)

  Input schema definition for the 'analyze_code_quality' tool, specifying parameters like files, patterns, options.

  inputSchema: {
    type: 'object',
    properties: {
      files: {
        type: 'array',
        items: { type: 'string' },
        description: 'File paths or glob patterns to analyze',
      },
      includePatterns: {
        type: 'array',
        items: { type: 'string' },
        description: 'File patterns to include',
      },
      excludePatterns: {
        type: 'array',
        items: { type: 'string' },
        description: 'File patterns to exclude',
      },
      maxComplexity: {
        type: 'number',
        description: 'Maximum allowed complexity',
      },
      checkDuplicates: {
        type: 'boolean',
        description: 'Check for duplicate code',
        default: true,
      },
      checkCodeSmells: {
        type: 'boolean',
        description: 'Check for code smells',
        default: true,
      },
    },
    required: ['files'],
  },

• src/tools/code-quality.ts:9-47 (registration)

  Tool registration/definition in the codeQualityTools array, including name, description, and input schema.

  {
    name: 'analyze_code_quality',
    description: 'Analyze overall code quality including complexity, maintainability, code smells, and duplications',
    inputSchema: {
      type: 'object',
      properties: {
        files: {
          type: 'array',
          items: { type: 'string' },
          description: 'File paths or glob patterns to analyze',
        },
        includePatterns: {
          type: 'array',
          items: { type: 'string' },
          description: 'File patterns to include',
        },
        excludePatterns: {
          type: 'array',
          items: { type: 'string' },
          description: 'File patterns to exclude',
        },
        maxComplexity: {
          type: 'number',
          description: 'Maximum allowed complexity',
        },
        checkDuplicates: {
          type: 'boolean',
          description: 'Check for duplicate code',
          default: true,
        },
        checkCodeSmells: {
          type: 'boolean',
          description: 'Check for code smells',
          default: true,
        },
      },
      required: ['files'],
    },
  },

• src/analyzers/code-analyzer.ts:8-33 (helper)

  Core implementation of code quality analysis in CodeAnalyzer class. Computes metrics like complexity, maintainability, smells, duplications.

  async analyzeCodeQuality(
    files: CodeFile[] | string[],
    options?: CodeAnalysisOptions
  ): Promise<CodeQualityMetrics> {
    const codeFiles = await this.getCodeFiles(files);
    
    const totalLines = codeFiles.reduce((sum, file) => sum + file.lines, 0);
    const complexity = this.calculateAverageComplexity(codeFiles);
    const maintainabilityIndex = this.calculateMaintainabilityIndex(codeFiles, complexity);
    const codeSmells = options?.checkCodeSmells !== false 
      ? this.detectCodeSmells(codeFiles, options)
      : [];
    const duplications = options?.checkDuplicates !== false
      ? await this.findDuplications(codeFiles, options)
      : [];
  
    return {
      complexity,
      maintainabilityIndex,
      technicalDebt: this.estimateTechnicalDebt(codeSmells, duplications.length),
      codeSmells,
      duplications,
      linesOfCode: totalLines,
      cyclomaticComplexity: complexity,
    };
  }