Code Merge MCP

Instructions

Implementation Reference

• src/tools/analyze_code.js:15-147 (handler)

  The primary handler function `handleRequest` that implements the core logic of the `analyze_code` tool: resolves paths, lists files recursively if directory, filters by language, reads contents, counts lines and functions per language heuristics, and returns aggregated statistics.
  async function handleRequest(parameters) { console.error('analyze_code: Starting execution'); const startTime = Date.now(); const { path: targetPath, language, countLines = true, countFunctions = true } = parameters; if (!targetPath) { throw new Error("Missing required parameter: 'path'."); } // Resolve to absolute path const absolutePath = path.resolve(targetPath); console.error(`analyze_code: Resolved path to ${absolutePath}`); let rootPath = absolutePath; // Assume path is directory initially let filesToProcess = []; // Validate path existence and determine if it's a file or directory try { const stats = await fs.stat(absolutePath); console.error(`analyze_code: Path exists, checking type`); if (stats.isDirectory()) { // Path is a directory, list files within it console.error(`analyze_code: Path is a directory, listing files`); rootPath = absolutePath; // Keep rootPath as the directory itself // Get all files in the directory recursively filesToProcess = await listFilesRecursive(absolutePath); // Filter by language if specified if (language) { const extensions = getExtensionsForLanguage(language); filesToProcess = filesToProcess.filter(file => { const ext = path.extname(file).toLowerCase(); return extensions.includes(ext); }); } console.error(`analyze_code: Found ${filesToProcess.length} files to analyze`); } else if (stats.isFile()) { // Path is a single file console.error(`analyze_code: Path is a file`); rootPath = path.dirname(absolutePath); // Set rootPath to the parent directory const relativeFilePath = path.basename(absolutePath); // Check if language filter applies if (language) { const extensions = getExtensionsForLanguage(language); const ext = path.extname(relativeFilePath).toLowerCase(); if (!extensions.includes(ext)) { console.error(`analyze_code: File ${relativeFilePath} does not match language filter ${language}`); filesToProcess = []; // Skip if language doesn't match } else { filesToProcess.push(relativeFilePath); } } else { filesToProcess.push(relativeFilePath); } console.error(`analyze_code: Added single file to process: ${relativeFilePath}`); } else { // Path exists but is not a file or directory (e.g., socket, fifo) throw new Error(`Path '${targetPath}' is not a file or directory.`); } } catch (error) { if (error.code === 'ENOENT') { throw new Error(`Path '${targetPath}' not found.`); } throw new Error(`Error accessing path '${targetPath}': ${error.message}`); } if (filesToProcess.length === 0) { // If no files are left after filtering console.error(`analyze_code: No files to process, returning empty analysis`); return { analysis: { totalFiles: 0, totalLines: 0, totalFunctions: 0, fileBreakdown: [] } }; } // Read the content of the files console.error(`analyze_code: Reading content of ${filesToProcess.length} files`); const fileContentsMap = await readFiles(filesToProcess, rootPath); // Analyze the files console.error(`analyze_code: Analyzing files`); const analysis = { totalFiles: filesToProcess.length, totalLines: 0, totalFunctions: 0, fileBreakdown: [] }; // Sort file paths before analyzing for deterministic output const sortedRelativePaths = [...fileContentsMap.keys()].sort((a, b) => a.localeCompare(b)); for (const relativeFilePath of sortedRelativePaths) { const content = fileContentsMap.get(relativeFilePath); if (content !== undefined) { // Check if file read was successful const fileAnalysis = { file: relativeFilePath, lines: 0, functions: 0 }; // Count lines if requested if (countLines) { fileAnalysis.lines = content.split('\n').length; analysis.totalLines += fileAnalysis.lines; } // Count functions if requested if (countFunctions) { fileAnalysis.functions = countFunctionsInCode(content, path.extname(relativeFilePath)); analysis.totalFunctions += fileAnalysis.functions; } analysis.fileBreakdown.push(fileAnalysis); } } const executionTime = Date.now() - startTime; console.error(`analyze_code: Execution completed in ${executionTime}ms`); return { analysis }; }
• src/mcp-server.js:186-211 (registration)

  Registration of the `analyze_code` tool using `server.tool()`, including the tool name, description, Zod input schema, and wrapper that calls the handler and adapts the result.
  // Register the analyze_code tool if (analyzeCodeHandler) { server.tool( 'analyze_code', 'Analyzes code files and provides statistics.', { path: z.string().describe('The target file or directory path.'), language: z.string().optional().describe('Optional language filter.'), countLines: z.boolean().optional().describe('Whether to count lines of code.'), countFunctions: z.boolean().optional().describe('Whether to count functions.') }, async (params) => { logInfo(`Executing analyze_code tool with params: ${JSON.stringify(params)}`); try { const startTime = Date.now(); const result = await analyzeCodeHandler(params); const executionTime = Date.now() - startTime; logDebug(`analyze_code completed in ${executionTime}ms`); return adaptToolResult(result); } catch (error) { logError('Error in analyze_code tool:', error); throw error; } } ); }
• src/mcp-server.js:191-196 (schema)

  Zod schema defining the input parameters for the `analyze_code` tool: path (required), language (optional), countLines and countFunctions (optional booleans).
  { path: z.string().describe('The target file or directory path.'), language: z.string().optional().describe('Optional language filter.'), countLines: z.boolean().optional().describe('Whether to count lines of code.'), countFunctions: z.boolean().optional().describe('Whether to count functions.') },
• src/tools/analyze_code.js:204-236 (helper)

  `countFunctionsInCode` helper: language-specific regex-based function counting (JS/TS arrow funcs/methods, Python def, Java methods).
  function countFunctionsInCode(code, fileExtension) { // This is a very simple implementation and won't catch all functions // A real implementation would use language-specific parsers let count = 0; // JavaScript/TypeScript if (['.js', '.jsx', '.ts', '.tsx', '.mjs'].includes(fileExtension.toLowerCase())) { // Count function declarations const functionMatches = code.match(/function\s+\w+\s*\(/g) || []; count += functionMatches.length; // Count arrow functions const arrowMatches = code.match(/\w+\s*=\s*\([^)]*\)\s*=>/g) || []; count += arrowMatches.length; // Count method definitions const methodMatches = code.match(/\w+\s*\([^)]*\)\s*{/g) || []; count += methodMatches.length; } // Python else if (['.py', '.pyw'].includes(fileExtension.toLowerCase())) { const functionMatches = code.match(/def\s+\w+\s*\(/g) || []; count += functionMatches.length; } // Java else if (['.java'].includes(fileExtension.toLowerCase())) { // This is a very simplified approach const methodMatches = code.match(/\w+\s+\w+\s*\([^)]*\)\s*{/g) || []; count += methodMatches.length; } return count; }
• src/tools/analyze_code.js:154-169 (helper)

  `listFilesRecursive` helper: recursively lists all files in a directory, returning relative paths.
  async function listFilesRecursive(dir, baseDir = dir, result = []) { const entries = await fs.readdir(dir, { withFileTypes: true }); for (const entry of entries) { const fullPath = path.join(dir, entry.name); const relativePath = path.relative(baseDir, fullPath); if (entry.isDirectory()) { await listFilesRecursive(fullPath, baseDir, result); } else if (entry.isFile()) { result.push(relativePath); } } return result; }