code-auditor-mcp 1.1.1 → 1.2.0

package/dist/mcp.js

@@ -9,8 +9,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 console.error(chalk.blue('[INFO]'), 'MCP SDK loaded');
 import { createAuditRunner } from './auditRunner.js';
 console.error(chalk.blue('[INFO]'), 'Audit runner loaded');
-import { registerFunctions, searchFunctions, getIndexStats, findDefinition, clearIndex, syncFileIndex } from './codeIndexService.js';
-import { scanFunctionsInFile, scanFunctionsInDirectory } from './functionScanner.js';
+import { searchFunctions, findDefinition, syncFileIndex } from './codeIndexService.js';
 import { ConfigGeneratorFactory } from './generators/ConfigGeneratorFactory.js';
 import { DEFAULT_SERVER_URL } from './constants.js';
 console.error(chalk.blue('[INFO]'), 'Code index service loaded');
@@ -19,19 +18,20 @@ import fs from 'node:fs/promises';
 import { CodeIndexDB } from './codeIndexDB.js';
 console.error(chalk.blue('[INFO]'), 'All modules loaded successfully');
 const tools = [
+    // Core Audit Tools
     {
-        name: 'audit_run',
-        description: 'Run a comprehensive code audit on the specified codebase',
+        name: 'audit',
+        description: 'Run a comprehensive code audit on files or directories',
         parameters: [
             {
                 name: 'path',
                 type: 'string',
                 required: false,
-                description: 'The directory path to audit (defaults to current directory)',
+                description: 'The file or directory path to audit (defaults to current directory)',
                 default: process.cwd(),
             },
             {
-                name: 'enabledAnalyzers',
+                name: 'analyzers',
                 type: 'array',
                 required: false,
                 description: 'List of analyzers to run (solid, dry, security, component, data-access)',
@@ -45,29 +45,17 @@ const tools = [
                 default: 'warning',
                 enum: ['info', 'warning', 'critical'],
             },
-        ],
-    },
-    {
-        name: 'audit_analyze_file',
-        description: 'Analyze a specific file for code quality issues',
-        parameters: [
             {
-                name: 'filePath',
-                type: 'string',
-                required: true,
-                description: 'The file path to analyze',
-            },
-            {
-                name: 'analyzers',
-                type: 'array',
+                name: 'indexFunctions',
+                type: 'boolean',
                 required: false,
-                description: 'Specific analyzers to run on this file',
-                default: ['solid', 'dry', 'security'],
+                description: 'Automatically index functions during audit',
+                default: true,
             },
         ],
     },
     {
-        name: 'audit_check_health',
+        name: 'audit_health',
         description: 'Quick health check of a codebase with key metrics',
         parameters: [
             {
@@ -84,41 +72,25 @@ const tools = [
                 description: 'Health score threshold (0-100) for pass/fail',
                 default: 70,
             },
-        ],
-    },
-    {
-        name: 'audit_list_analyzers',
-        description: 'List all available code analyzers and their capabilities',
-        parameters: [],
-    },
-    {
-        name: 'register_functions',
-        description: 'Register functions with metadata for code indexing',
-        parameters: [
             {
-                name: 'functions',
-                type: 'array',
-                required: true,
-                description: 'Array of function objects with metadata',
-            },
-            {
-                name: 'overwrite',
+                name: 'indexFunctions',
                 type: 'boolean',
                 required: false,
-                description: 'Whether to overwrite existing entries',
-                default: false,
+                description: 'Automatically index functions during health check',
+                default: true,
             },
         ],
     },
+    // Code Index Tools
     {
-        name: 'search_functions',
-        description: 'Search registered functions by various criteria',
+        name: 'search_code',
+        description: 'Search indexed functions with natural language queries',
         parameters: [
             {
                 name: 'query',
                 type: 'string',
                 required: true,
-                description: 'Search query (supports full-text search)',
+                description: 'Search query (supports natural language)',
             },
             {
                 name: 'filters',
@@ -142,41 +114,15 @@ const tools = [
             },
         ],
     },
-    {
-        name: 'index_functions',
-        description: 'Index functions from TypeScript/JavaScript files',
-        parameters: [
-            {
-                name: 'path',
-                type: 'string',
-                required: true,
-                description: 'File or directory path to index',
-            },
-            {
-                name: 'recursive',
-                type: 'boolean',
-                required: false,
-                description: 'Recursively index directories',
-                default: true,
-            },
-            {
-                name: 'fileTypes',
-                type: 'array',
-                required: false,
-                description: 'File extensions to process',
-                default: ['.ts', '.tsx', '.js', '.jsx'],
-            },
-        ],
-    },
     {
         name: 'find_definition',
-        description: 'Find the definition of a specific function',
+        description: 'Find the exact definition of a specific function',
         parameters: [
             {
                 name: 'name',
                 type: 'string',
                 required: true,
-                description: 'Function name to search for',
+                description: 'Function name to find',
             },
             {
                 name: 'filePath',
@@ -187,39 +133,35 @@ const tools = [
         ],
     },
     {
-        name: 'get_index_stats',
-        description: 'Get statistics about the code index',
-        parameters: [],
-    },
-    {
-        name: 'clear_index',
-        description: 'Clear all indexed functions',
+        name: 'sync_index',
+        description: 'Synchronize, cleanup, or reset the code index',
         parameters: [
             {
-                name: 'confirm',
-                type: 'boolean',
+                name: 'mode',
+                type: 'string',
                 required: false,
-                description: 'Confirm clearing the index',
-                default: false,
+                description: 'Operation mode: sync (update), cleanup (remove stale), or reset (clear all)',
+                default: 'sync',
+                enum: ['sync', 'cleanup', 'reset'],
+            },
+            {
+                name: 'path',
+                type: 'string',
+                required: false,
+                description: 'Optional specific path to sync',
             },
         ],
     },
+    // AI Configuration Tool
     {
-        name: 'generate_ai_configs',
+        name: 'generate_ai_config',
         description: 'Generate configuration files for AI coding assistants',
         parameters: [
             {
                 name: 'tools',
                 type: 'array',
                 required: true,
-                description: 'AI tools to generate configs for (cursor, continue, copilot, claude, etc.)',
-            },
-            {
-                name: 'serverUrl',
-                type: 'string',
-                required: false,
-                description: 'MCP server URL',
-                default: DEFAULT_SERVER_URL,
+                description: 'AI tools to configure (cursor, continue, copilot, claude, zed, windsurf, cody, aider, cline, pearai)',
             },
             {
                 name: 'outputDir',
@@ -228,60 +170,8 @@ const tools = [
                 description: 'Output directory for configuration files',
                 default: '.',
             },
-            {
-                name: 'overwrite',
-                type: 'boolean',
-                required: false,
-                description: 'Overwrite existing files',
-                default: false,
-            },
-        ],
-    },
-    {
-        name: 'list_ai_tools',
-        description: 'List all supported AI tools for configuration generation',
-        parameters: [],
-    },
-    {
-        name: 'get_ai_tool_info',
-        description: 'Get detailed information about a specific AI tool',
-        parameters: [
-            {
-                name: 'tool',
-                type: 'string',
-                required: true,
-                description: 'AI tool name (cursor, continue, copilot, etc.)',
-            },
         ],
     },
-    {
-        name: 'validate_ai_config',
-        description: 'Validate a generated AI tool configuration',
-        parameters: [
-            {
-                name: 'tool',
-                type: 'string',
-                required: true,
-                description: 'AI tool name',
-            },
-            {
-                name: 'config',
-                type: 'object',
-                required: true,
-                description: 'Configuration object to validate',
-            },
-        ],
-    },
-    {
-        name: 'bulk_cleanup',
-        description: 'Remove index entries for deleted files',
-        parameters: [],
-    },
-    {
-        name: 'deep_sync',
-        description: 'Deep synchronize all indexed files to update signatures and remove stale entries',
-        parameters: [],
-    },
 ];
 async function startMcpServer() {
     console.error(chalk.blue('[INFO]'), 'Starting Code Auditor MCP Server...');
@@ -326,16 +216,46 @@ async function startMcpServer() {
         try {
             let result;
             switch (name) {
-                case 'audit_run': {
+                case 'audit': {
                     const auditPath = path.resolve(args.path || process.cwd());
+                    const indexFunctions = args.indexFunctions !== false; // Default true
+                    // Check if path is a file or directory
+                    const stats = await fs.stat(auditPath).catch(() => null);
+                    const isFile = stats?.isFile() || false;
                     const options = {
-                        projectRoot: auditPath,
-                        enabledAnalyzers: args.enabledAnalyzers || ['solid', 'dry', 'security'],
+                        projectRoot: isFile ? path.dirname(auditPath) : auditPath,
+                        enabledAnalyzers: args.analyzers || ['solid', 'dry', 'security'],
                         minSeverity: (args.minSeverity || 'warning'),
                         verbose: false,
+                        indexFunctions,
+                        ...(isFile && { includePaths: [auditPath] }),
                     };
                     const runner = createAuditRunner(options);
                     const auditResult = await runner.run();
+                    // Handle function indexing if enabled and functions were collected
+                    let indexingResult = null;
+                    if (indexFunctions && auditResult.metadata.fileToFunctionsMap) {
+                        try {
+                            const syncStats = { added: 0, updated: 0, removed: 0 };
+                            // Sync each file's functions to handle additions, updates, and removals
+                            for (const [filePath, functions] of Object.entries(auditResult.metadata.fileToFunctionsMap)) {
+                                const fileStats = await syncFileIndex(filePath, functions);
+                                syncStats.added += fileStats.added;
+                                syncStats.updated += fileStats.updated;
+                                syncStats.removed += fileStats.removed;
+                            }
+                            indexingResult = {
+                                success: true,
+                                registered: syncStats.added + syncStats.updated,
+                                failed: 0,
+                                syncStats
+                            };
+                            console.error(chalk.blue('[INFO]'), `Synced functions: ${syncStats.added} added, ${syncStats.updated} updated, ${syncStats.removed} removed`);
+                        }
+                        catch (error) {
+                            console.error(chalk.yellow('[WARN]'), 'Failed to sync functions:', error);
+                        }
+                    }
                     // Format for MCP
                     result = {
                         summary: {
@@ -349,46 +269,47 @@ async function startMcpServer() {
                         },
                         violations: getAllViolations(auditResult).slice(0, 100), // Limit to first 100
                         recommendations: auditResult.recommendations,
+                        ...(indexingResult && { functionIndexing: indexingResult }),
                     };
                     break;
                 }
-                case 'audit_analyze_file': {
-                    const absolutePath = path.resolve(args.filePath);
-                    await fs.access(absolutePath); // Check file exists
-                    const options = {
-                        projectRoot: path.dirname(absolutePath),
-                        enabledAnalyzers: args.analyzers || ['solid', 'dry', 'security'],
-                        includePaths: [absolutePath],
-                        verbose: false,
-                    };
-                    const runner = createAuditRunner(options);
-                    const auditResult = await runner.run();
-                    const fileViolations = getAllViolations(auditResult).filter(v => v.file === absolutePath);
-                    result = {
-                        file: absolutePath,
-                        violations: fileViolations,
-                        summary: {
-                            total: fileViolations.length,
-                            bySeverity: fileViolations
-                                .reduce((acc, v) => {
-                                acc[v.severity] = (acc[v.severity] || 0) + 1;
-                                return acc;
-                            }, {}),
-                        },
-                    };
-                    break;
-                }
-                case 'audit_check_health': {
+                case 'audit_health': {
                     const auditPath = path.resolve(args.path || process.cwd());
                     const threshold = args.threshold || 70;
+                    const indexFunctions = args.indexFunctions !== false; // Default true
                     const runner = createAuditRunner({
                         projectRoot: auditPath,
                         enabledAnalyzers: ['solid', 'dry', 'security'],
                         minSeverity: 'warning',
                         verbose: false,
+                        indexFunctions, // Pass the flag to the runner
                     });
                     const auditResult = await runner.run();
                     const healthScore = calculateHealthScore(auditResult);
+                    // Handle function indexing if enabled and functions were collected
+                    let indexingResult = null;
+                    if (indexFunctions && auditResult.metadata.fileToFunctionsMap) {
+                        try {
+                            const syncStats = { added: 0, updated: 0, removed: 0 };
+                            // Sync each file's functions to handle additions, updates, and removals
+                            for (const [filePath, functions] of Object.entries(auditResult.metadata.fileToFunctionsMap)) {
+                                const fileStats = await syncFileIndex(filePath, functions);
+                                syncStats.added += fileStats.added;
+                                syncStats.updated += fileStats.updated;
+                                syncStats.removed += fileStats.removed;
+                            }
+                            indexingResult = {
+                                success: true,
+                                registered: syncStats.added + syncStats.updated,
+                                failed: 0,
+                                syncStats
+                            };
+                            console.error(chalk.blue('[INFO]'), `Synced functions: ${syncStats.added} added, ${syncStats.updated} updated, ${syncStats.removed} removed`);
+                        }
+                        catch (error) {
+                            console.error(chalk.yellow('[WARN]'), 'Failed to sync functions:', error);
+                        }
+                    }
                     result = {
                         healthScore,
                         threshold,
@@ -401,82 +322,11 @@ async function startMcpServer() {
                             warningViolations: auditResult.summary.warnings,
                         },
                         recommendation: getHealthRecommendation(healthScore, auditResult),
+                        ...(indexingResult && { functionIndexing: indexingResult }),
                     };
                     break;
                 }
-                case 'audit_list_analyzers': {
-                    result = {
-                        analyzers: [
-                            {
-                                id: 'solid',
-                                name: 'SOLID Analyzer',
-                                description: 'Checks adherence to SOLID principles',
-                                checks: [
-                                    'Single Responsibility violations',
-                                    'Open/Closed violations',
-                                    'Liskov Substitution issues',
-                                    'Interface Segregation problems',
-                                    'Dependency Inversion violations',
-                                ],
-                            },
-                            {
-                                id: 'dry',
-                                name: 'DRY Analyzer',
-                                description: 'Identifies code duplication',
-                                checks: [
-                                    'Exact code duplicates',
-                                    'Similar code patterns',
-                                    'Duplicate imports',
-                                    'Repeated string literals',
-                                ],
-                            },
-                            {
-                                id: 'security',
-                                name: 'Security Analyzer',
-                                description: 'Verifies security patterns',
-                                checks: [
-                                    'Missing authentication',
-                                    'Authorization issues',
-                                    'SQL injection risks',
-                                    'Unvalidated inputs',
-                                ],
-                            },
-                            {
-                                id: 'component',
-                                name: 'Component Analyzer',
-                                description: 'Analyzes UI components',
-                                checks: [
-                                    'Missing error boundaries',
-                                    'Complex render methods',
-                                    'Deep nesting',
-                                    'Performance issues',
-                                ],
-                            },
-                            {
-                                id: 'data-access',
-                                name: 'Data Access Analyzer',
-                                description: 'Reviews database patterns',
-                                checks: [
-                                    'N+1 queries',
-                                    'Missing transactions',
-                                    'Direct DB access in UI',
-                                    'Performance issues',
-                                ],
-                            },
-                        ],
-                    };
-                    break;
-                }
-                case 'register_functions': {
-                    const functions = args.functions;
-                    const overwrite = args.overwrite || false;
-                    if (!Array.isArray(functions)) {
-                        throw new Error('functions must be an array');
-                    }
-                    result = await registerFunctions(functions, { overwrite });
-                    break;
-                }
-                case 'search_functions': {
+                case 'search_code': {
                     const query = args.query;
                     const filters = args.filters;
                     const limit = args.limit || 50;
@@ -493,36 +343,6 @@ async function startMcpServer() {
                     });
                     break;
                 }
-                case 'index_functions': {
-                    const targetPath = path.resolve(args.path);
-                    const recursive = args.recursive !== false;
-                    const fileTypes = args.fileTypes || ['.ts', '.tsx', '.js', '.jsx'];
-                    const stats = await fs.stat(targetPath);
-                    if (stats.isFile()) {
-                        // For single files, use sync to handle additions/updates/removals
-                        const functions = await scanFunctionsInFile(targetPath);
-                        const syncResult = await syncFileIndex(targetPath, functions);
-                        result = {
-                            success: true,
-                            registered: syncResult.added + syncResult.updated,
-                            failed: 0,
-                            path: targetPath,
-                            totalScanned: functions.length,
-                            syncStats: syncResult
-                        };
-                    }
-                    else {
-                        // For directories, use regular registration (could be improved later)
-                        const functions = await scanFunctionsInDirectory(targetPath, { recursive, fileTypes });
-                        const registerResult = await registerFunctions(functions);
-                        result = {
-                            ...registerResult,
-                            path: targetPath,
-                            totalScanned: functions.length,
-                        };
-                    }
-                    break;
-                }
                 case 'find_definition': {
                     const name = args.name;
                     const filePath = args.filePath;
@@ -533,20 +353,7 @@ async function startMcpServer() {
                     result = definition || { error: 'Function not found' };
                     break;
                 }
-                case 'get_index_stats': {
-                    result = await getIndexStats();
-                    break;
-                }
-                case 'clear_index': {
-                    const confirm = args.confirm;
-                    if (!confirm) {
-                        throw new Error('Please set confirm: true to clear the index');
-                    }
-                    await clearIndex();
-                    result = { message: 'Index cleared successfully' };
-                    break;
-                }
-                case 'generate_ai_configs': {
+                case 'generate_ai_config': {
                     const tools = args.tools;
                     const serverUrl = args.serverUrl || DEFAULT_SERVER_URL;
                     const outputDir = args.outputDir || '.';
@@ -607,121 +414,63 @@ async function startMcpServer() {
                     };
                     break;
                 }
-                case 'list_ai_tools': {
-                    const factory = new ConfigGeneratorFactory();
-                    const toolInfo = factory.getToolInfo();
-                    result = {
-                        tools: toolInfo,
-                        totalCount: toolInfo.length,
-                        categories: {
-                            native_mcp: toolInfo.filter(t => !t.requiresAuth).map(t => t.name),
-                            api_based: toolInfo.filter(t => t.requiresAuth).map(t => t.name)
+                case 'sync_index': {
+                    const mode = args.mode || 'sync';
+                    const targetPath = args.path;
+                    const db = CodeIndexDB.getInstance();
+                    await db.initialize();
+                    switch (mode) {
+                        case 'cleanup': {
+                            const cleanupResult = await db.bulkCleanup();
+                            result = {
+                                mode: 'cleanup',
+                                success: true,
+                                scannedFiles: cleanupResult.scannedCount,
+                                removedEntries: cleanupResult.removedCount,
+                                removedFiles: cleanupResult.removedFiles,
+                                errors: cleanupResult.errors,
+                                message: `Cleaned up ${cleanupResult.removedCount} entries from ${cleanupResult.removedFiles.length} deleted files`
+                            };
+                            break;
                         }
-                    };
-                    break;
-                }
-                case 'get_ai_tool_info': {
-                    const toolName = args.tool;
-                    if (!toolName) {
-                        throw new Error('tool parameter is required');
-                    }
-                    const factory = new ConfigGeneratorFactory();
-                    const generator = factory.createGenerator(toolName);
-                    if (!generator) {
-                        throw new Error(`Unknown tool: ${toolName}`);
-                    }
-                    const config = generator.generateConfig();
-                    result = {
-                        name: toolName,
-                        displayName: generator.getToolName(),
-                        requiresAuth: generator.requiresAuth(),
-                        defaultApiKey: generator.getDefaultApiKey(),
-                        configFilename: generator.getFilename(),
-                        instructions: generator.getInstructions(),
-                        sampleConfig: JSON.parse(config.content)
-                    };
-                    break;
-                }
-                case 'validate_ai_config': {
-                    const toolName = args.tool;
-                    const config = args.config;
-                    if (!toolName) {
-                        throw new Error('tool parameter is required');
-                    }
-                    if (!config) {
-                        throw new Error('config parameter is required');
-                    }
-                    const factory = new ConfigGeneratorFactory();
-                    const generator = factory.createGenerator(toolName);
-                    if (!generator) {
-                        throw new Error(`Unknown tool: ${toolName}`);
-                    }
-                    // Generate reference config to compare structure
-                    const referenceConfig = generator.generateConfig();
-                    const reference = JSON.parse(referenceConfig.content);
-                    // Basic validation - check if main structure matches
-                    const errors = [];
-                    const validateObject = (ref, actual, path = '') => {
-                        for (const key in ref) {
-                            const currentPath = path ? `${path}.${key}` : key;
-                            if (!(key in actual)) {
-                                errors.push(`Missing required field: ${currentPath}`);
+                        case 'reset': {
+                            await db.clearIndex();
+                            result = {
+                                mode: 'reset',
+                                success: true,
+                                message: 'Index cleared successfully'
+                            };
+                            break;
+                        }
+                        case 'sync':
+                        default: {
+                            if (targetPath) {
+                                // Sync specific file
+                                const syncResult = await db.synchronizeFile(path.resolve(targetPath));
+                                result = {
+                                    mode: 'sync',
+                                    success: true,
+                                    path: targetPath,
+                                    ...(syncResult || { message: 'File not found' })
+                                };
                             }
-                            else if (typeof ref[key] === 'object' && ref[key] !== null && !Array.isArray(ref[key])) {
-                                if (typeof actual[key] === 'object' && actual[key] !== null) {
-                                    validateObject(ref[key], actual[key], currentPath);
-                                }
-                                else {
-                                    errors.push(`Field ${currentPath} should be an object`);
-                                }
+                            else {
+                                // Deep sync all files
+                                const syncResult = await db.deepSync();
+                                result = {
+                                    mode: 'sync',
+                                    success: true,
+                                    syncedFiles: syncResult.syncedFiles,
+                                    addedFunctions: syncResult.addedFunctions,
+                                    updatedFunctions: syncResult.updatedFunctions,
+                                    removedFunctions: syncResult.removedFunctions,
+                                    errors: syncResult.errors,
+                                    message: `Synced ${syncResult.syncedFiles} files: ${syncResult.addedFunctions} added, ${syncResult.updatedFunctions} updated, ${syncResult.removedFunctions} removed`
+                                };
                             }
+                            break;
                         }
-                    };
-                    validateObject(reference, config);
-                    result = {
-                        valid: errors.length === 0,
-                        tool: toolName,
-                        errors: errors.length > 0 ? errors : undefined,
-                        warnings: [] // Could add warnings for extra fields, deprecated settings, etc.
-                    };
-                    break;
-                }
-                case 'bulk_cleanup': {
-                    const db = CodeIndexDB.getInstance();
-                    await db.initialize();
-                    const cleanupResult = await db.bulkCleanup();
-                    result = {
-                        success: true,
-                        scannedFiles: cleanupResult.scannedCount,
-                        removedEntries: cleanupResult.removedCount,
-                        removedFiles: cleanupResult.removedFiles,
-                        errors: cleanupResult.errors,
-                        message: `Cleaned up ${cleanupResult.removedCount} entries from ${cleanupResult.removedFiles.length} deleted files`
-                    };
-                    break;
-                }
-                case 'deep_sync': {
-                    const db = CodeIndexDB.getInstance();
-                    await db.initialize();
-                    // Progress tracking
-                    const progressUpdates = [];
-                    const syncResult = await db.deepSync((progress) => {
-                        progressUpdates.push({
-                            current: progress.current,
-                            total: progress.total,
-                            file: progress.file,
-                            percentage: Math.round((progress.current / progress.total) * 100)
-                        });
-                    });
-                    result = {
-                        success: true,
-                        syncedFiles: syncResult.syncedFiles,
-                        addedFunctions: syncResult.addedFunctions,
-                        updatedFunctions: syncResult.updatedFunctions,
-                        removedFunctions: syncResult.removedFunctions,
-                        errors: syncResult.errors,
-                        message: `Synced ${syncResult.syncedFiles} files: ${syncResult.addedFunctions} added, ${syncResult.updatedFunctions} updated, ${syncResult.removedFunctions} removed`
-                    };
+                    }
                     break;
                 }
                 default: