analyze_file_differences

Instructions

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "file1": "<file1>",
      "file2": "<file2>"
    },
    "name": "analyze_file_differences"
  }
}

Implementation Reference

• src/services/FileService.ts:1083-1196 (handler)

  The main handler function that performs the file difference analysis. It reads two files, performs a line-by-line comparison, categorizes differences as added/removed/modified, computes statistics, and returns a formatted text result.

  async analyzeFileDifferences(file1: string, file2: string): Promise<ToolResult> {
    try {
      const fullPath1 = this.workspaceService.resolvePath(file1);
      const fullPath2 = this.workspaceService.resolvePath(file2);
      
      // Read both files
      const content1 = await fs.readFile(fullPath1, 'utf-8');
      const content2 = await fs.readFile(fullPath2, 'utf-8');
      
      const lines1 = content1.split('\n');
      const lines2 = content2.split('\n');
      
      const result: FileComparisonResult = {
        identical: content1 === content2,
        differences: [],
        stats: {
          linesAdded: 0,
          linesRemoved: 0,
          linesModified: 0
        }
      };
      
      // Simple line-by-line comparison
      const maxLines = Math.max(lines1.length, lines2.length);
      
      for (let i = 0; i < maxLines; i++) {
        const line1 = lines1[i];
        const line2 = lines2[i];
        
        if (line1 === undefined) {
          // Line added in file2
          result.differences.push({
            line: i + 1,
            type: 'added',
            content: line2
          });
          result.stats.linesAdded++;
        } else if (line2 === undefined) {
          // Line removed from file1
          result.differences.push({
            line: i + 1,
            type: 'removed',
            content: line1
          });
          result.stats.linesRemoved++;
        } else if (line1 !== line2) {
          // Line modified
          result.differences.push({
            line: i + 1,
            type: 'modified',
            content: line2,
            oldContent: line1
          });
          result.stats.linesModified++;
        }
      }
      
      // Format the output
      let output = `File Comparison Analysis:\n`;
      output += `File 1: ${file1}\n`;
      output += `File 2: ${file2}\n`;
      output += `Identical: ${result.identical}\n\n`;
      
      if (!result.identical) {
        output += `Statistics:\n`;
        output += `- Lines added: ${result.stats.linesAdded}\n`;
        output += `- Lines removed: ${result.stats.linesRemoved}\n`;
        output += `- Lines modified: ${result.stats.linesModified}\n`;
        output += `- Total differences: ${result.differences.length}\n\n`;
        
        if (result.differences.length <= 50) {
          output += `Differences:\n`;
          for (const diff of result.differences) {
            switch (diff.type) {
              case 'added':
                output += `+ Line ${diff.line}: ${diff.content}\n`;
                break;
              case 'removed':
                output += `- Line ${diff.line}: ${diff.content}\n`;
                break;
              case 'modified':
                output += `~ Line ${diff.line}:\n`;
                output += `  - ${diff.oldContent}\n`;
                output += `  + ${diff.content}\n`;
                break;
            }
          }
        } else {
          output += `Too many differences to display (${result.differences.length}). Use compareFiles for detailed diff.`;
        }
      }
      
      return {
        content: [{
          type: 'text',
          text: output,
          _meta: {
            identical: result.identical,
            stats: result.stats,
            differenceCount: result.differences.length
          }
        }]
      };
      
    } catch (error) {
      return {
        isError: true,
        content: [{
          type: 'text',
          text: `File analysis failed: ${error instanceof Error ? error.message : String(error)}`
        }]
      };
    }
  }

• src/services/FileService.ts:67-80 (schema)

  The FileComparisonResult interface defining the return type structure: identical flag, differences array (with line number, type, content, oldContent), and stats (linesAdded, linesRemoved, linesModified).

  export interface FileComparisonResult {
    identical: boolean;
    differences: Array<{
      line: number;
      type: 'added' | 'removed' | 'modified';
      content: string;
      oldContent?: string;
    }>;
    stats: {
      linesAdded: number;
      linesRemoved: number;
      linesModified: number;
    };
  }

• src/index.ts:456-457 (registration)

  The tool dispatcher case statement that routes the 'analyze_file_differences' tool name to the fileService.analyzeFileDifferences handler method.

  case 'analyze_file_differences':
    return await this.fileService.analyzeFileDifferences(args.file1, args.file2);

• src/toolDefinitions.ts:866-877 (registration)

  The tool definition registration with input schema specifying file1 and file2 as required string parameters.

  {
    name: 'analyze_file_differences',
    description: 'Analyze differences between two files with detailed statistics',
    inputSchema: {
      type: 'object',
      properties: {
        file1: { type: 'string', description: 'First file path' },
        file2: { type: 'string', description: 'Second file path' }
      },
      required: ['file1', 'file2']
    }
  },