code-auditor-mcp 2.6.2 → 3.0.1

package/dist/mcp-standalone.js

@@ -1,1324 +0,0 @@
-#!/usr/bin/env node
-import './applyDataDirEnv.js';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, InitializeRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { createAuditRunner } from './auditRunner.js';
-import { syncFileIndex, searchFunctions, findDefinition, clearIndex } from './codeIndexService.js';
-import { CodeIndexDB } from './codeIndexDB.js';
-import { ConfigGeneratorFactory } from './generators/ConfigGeneratorFactory.js';
-import { IS_DEV_MODE, PACKAGE_VERSION } from './constants.js';
-import { scanFunctionsInDirectory } from './functionScanner.js';
-import path from 'node:path';
-import chalk from 'chalk';
-import { assertAuditPathExists, formatMcpToolErrorPayload } from './mcpToolErrors.js';
-import { logMcpInfo, mcpDebugStderr, mcpTraceStderr } from './mcpDiagnostics.js';
-import { createWriteStream } from 'node:fs';
-import { getAuditJobStatus, getAuditResultsPage, startAuditJob } from './mcpAuditJobs.js';
-// Set up file logging (only in development mode)
-let logStream = null;
-if (IS_DEV_MODE) {
-    const logFilePath = path.join(process.cwd(), 'mcp-server.log');
-    logStream = createWriteStream(logFilePath, { flags: 'a' });
-    console.error(chalk.blue('[INFO]'), `Development mode: Logging to file: ${logFilePath}`);
-}
-// Save original console.error (log is redirected to stderr; see below)
-const originalConsoleError = console.error;
-// Override console.log — MCP uses stdout only for JSON-RPC; log() must never touch stdout.
-console.log = (...args) => {
-    if (logStream) {
-        const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
-        const timestamp = new Date().toISOString();
-        logStream.write(`[${timestamp}] [LOG] ${message}\n`);
-    }
-    originalConsoleError.apply(console, args);
-};
-// Override console.error (with conditional file logging)
-console.error = (...args) => {
-    if (logStream) {
-        const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
-        const timestamp = new Date().toISOString();
-        logStream.write(`[${timestamp}] [ERROR] ${message}\n`);
-    }
-    originalConsoleError.apply(console, args);
-};
-const tools = [
-    {
-        name: 'audit',
-        description: 'Fetch paginated results for a completed audit by resultId (or auditId alias). This tool never starts a new audit.',
-        parameters: [
-            {
-                name: 'limit',
-                type: 'number',
-                required: false,
-                description: 'Maximum number of violations to return per page (default: 50, max: 100)',
-                default: 50,
-            },
-            {
-                name: 'offset',
-                type: 'number',
-                required: false,
-                description: 'Violation offset for pagination (default: 0)',
-                default: 0,
-            },
-            {
-                name: 'resultId',
-                type: 'string',
-                required: false,
-                description: 'Result ID returned by audit_status when the background audit job completes.',
-            },
-            {
-                name: 'auditId',
-                type: 'string',
-                required: false,
-                description: 'Backward-compatible alias for resultId.',
-            },
-        ],
-    },
-    {
-        name: 'start_audit',
-        description: 'Start a background audit job. Returns immediately with a jobId. Poll audit_status until completed, then fetch pages with audit or audit_results.',
-        parameters: [
-            {
-                name: 'path',
-                type: 'string',
-                required: false,
-                description: 'File or directory path to audit (defaults to current directory).',
-                default: process.cwd(),
-            },
-            {
-                name: 'analyzers',
-                type: 'array',
-                required: false,
-                description: 'Analyzers to run (default: solid, dry).',
-                default: ['solid', 'dry'],
-            },
-            {
-                name: 'minSeverity',
-                type: 'string',
-                required: false,
-                description: 'Minimum severity level to report.',
-                default: 'info',
-                enum: ['info', 'warning', 'critical'],
-            },
-            {
-                name: 'indexFunctions',
-                type: 'boolean',
-                required: false,
-                description: 'Index functions during audit (default: true).',
-                default: true,
-            },
-            {
-                name: 'analyzerConfigs',
-                type: 'object',
-                required: false,
-                description: 'Analyzer-specific configuration overrides.',
-            },
-            {
-                name: 'analyzerConcurrency',
-                type: 'number',
-                required: false,
-                description: 'Max analyzers to run in parallel (default: 1).',
-                default: 1,
-            },
-            {
-                name: 'partitionStrategy',
-                type: 'string',
-                required: false,
-                description: 'Partition mode: none | auto | top-level. auto shards when large source trees are detected.',
-                default: 'auto',
-                enum: ['none', 'auto', 'top-level'],
-            },
-            {
-                name: 'maxPartitions',
-                type: 'number',
-                required: false,
-                description: 'Maximum number of folder partitions for sharded audits (default: 4).',
-                default: 4,
-            },
-            {
-                name: 'partitionThresholdFiles',
-                type: 'number',
-                required: false,
-                description: 'Minimum discovered files before auto partitioning is enabled (default: 250).',
-                default: 250,
-            },
-            {
-                name: 'workerCount',
-                type: 'number',
-                required: false,
-                description: 'Number of worker processes for shard execution (default: min(4, CPU-1)).',
-            },
-            {
-                name: 'maxRetries',
-                type: 'number',
-                required: false,
-                description: 'Retry attempts per shard for retryable failures (default: 1).',
-                default: 1,
-            },
-            {
-                name: 'shardTimeoutMs',
-                type: 'number',
-                required: false,
-                description: 'Per-shard timeout in milliseconds (default: 180000).',
-                default: 180000,
-            },
-            {
-                name: 'retryBackoffMs',
-                type: 'number',
-                required: false,
-                description: 'Base retry backoff in milliseconds (default: 500).',
-                default: 500,
-            },
-            {
-                name: 'jobTimeoutMs',
-                type: 'number',
-                required: false,
-                description: 'Maximum wall time for the entire audit job (default 30m, env CODE_AUDITOR_JOB_TIMEOUT_MS, cap 4h). Aborts workers cooperatively then tears down.',
-            },
-            {
-                name: 'maxFilesPerRun',
-                type: 'number',
-                required: false,
-                description: 'Per worker chunk: if more files match than this, the worker finishes one chunk and the parent queues the rest on another worker (optional).',
-            },
-            {
-                name: 'shardSoftBudgetMs',
-                type: 'number',
-                required: false,
-                description: 'Per worker soft wall-clock budget; aborts in-process analysis cooperatively via AbortSignal so the parent can assign the next chunk to a fresh worker.',
-            },
-            {
-                name: 'generateCodeMap',
-                type: 'boolean',
-                required: false,
-                description: 'Generate code map artifacts during audit (default: false).',
-                default: false,
-            },
-        ],
-    },
-    {
-        name: 'audit_status',
-        description: 'Get current status for a previously started background audit job. Returns resultId when completed.',
-        parameters: [
-            {
-                name: 'jobId',
-                type: 'string',
-                required: true,
-                description: 'Job ID returned by start_audit.',
-            },
-        ],
-    },
-    {
-        name: 'audit_results',
-        description: 'Fetch paginated violations for a completed audit result by resultId.',
-        parameters: [
-            {
-                name: 'resultId',
-                type: 'string',
-                required: true,
-                description: 'Result ID returned by audit_status when status is completed.',
-            },
-            {
-                name: 'limit',
-                type: 'number',
-                required: false,
-                description: 'Maximum number of violations to return per page (default: 50, max: 100).',
-                default: 50,
-            },
-            {
-                name: 'offset',
-                type: 'number',
-                required: false,
-                description: 'Violation offset for pagination (default: 0).',
-                default: 0,
-            },
-        ],
-    },
-    {
-        name: 'audit_health',
-        description: 'Quick health check of a codebase with key metrics',
-        parameters: [
-            {
-                name: 'path',
-                type: 'string',
-                required: false,
-                description: 'The directory path to check',
-                default: process.cwd(),
-            },
-            {
-                name: 'threshold',
-                type: 'number',
-                required: false,
-                description: 'Health score threshold (0-100) for pass/fail',
-                default: 70,
-            },
-            {
-                name: 'indexFunctions',
-                type: 'boolean',
-                required: false,
-                description: 'Automatically index functions during health check',
-                default: true,
-            },
-        ],
-    },
-    {
-        name: 'search_code',
-        description: 'Search indexed functions and React components with natural language queries. Supports operators: entity:component, component:functional|class|memo|forwardRef, hook:useState|useEffect|etc, prop:propName, dep:packageName, dependency:lodash, uses:express, calls:functionName, calledby:functionName, dependents-of:functionName, used-by:functionName, depends-on:module, imports-from:file, unused-imports, dead-imports, type:fileType, file:path, lang:language, complexity:1-10, jsdoc:true|false',
-        parameters: [
-            {
-                name: 'query',
-                type: 'string',
-                required: true,
-                description: 'Search query with natural language and/or operators. Examples: "Button component:functional", "entity:component hook:useState", "render prop:onClick", "dep:lodash", "calls:validateUser", "unused-imports", "dependents-of:authenticate"',
-            },
-            {
-                name: 'filters',
-                type: 'object',
-                required: false,
-                description: 'Optional filters (language, filePath, dependencies, componentType, entityType, searchMode). Set searchMode to "content" to search within function bodies, "metadata" for names/signatures only, or "both" for combined search',
-            },
-            {
-                name: 'limit',
-                type: 'number',
-                required: false,
-                description: 'Maximum results to return',
-                default: 50,
-            },
-            {
-                name: 'offset',
-                type: 'number',
-                required: false,
-                description: 'Offset for pagination',
-                default: 0,
-            },
-        ],
-    },
-    {
-        name: 'find_definition',
-        description: 'Find the exact definition of a specific function',
-        parameters: [
-            {
-                name: 'name',
-                type: 'string',
-                required: true,
-                description: 'Function name to find',
-            },
-            {
-                name: 'filePath',
-                type: 'string',
-                required: false,
-                description: 'Optional file path to narrow search',
-            },
-        ],
-    },
-    {
-        name: 'sync_index',
-        description: 'Synchronize, cleanup, or reset analysis-derived data (indexed functions, cached audits, code maps, schema overlays). Project tasks, analyzer configs, and whitelist entries are preserved on reset.',
-        parameters: [
-            {
-                name: 'mode',
-                type: 'string',
-                required: false,
-                description: 'sync: update index from files; cleanup: remove index rows for deleted files; reset: clear all analysis-derived data (not tasks/config/whitelist)',
-                default: 'sync',
-                enum: ['sync', 'cleanup', 'reset'],
-            },
-            {
-                name: 'path',
-                type: 'string',
-                required: false,
-                description: 'Optional specific path to sync',
-            },
-        ],
-    },
-    {
-        name: 'generate_ai_config',
-        description: 'Generate configuration files for AI coding assistants',
-        parameters: [
-            {
-                name: 'tools',
-                type: 'array',
-                required: true,
-                description: 'AI tools to configure (cursor, continue, copilot, claude, zed, windsurf, cody, aider, cline, pearai)',
-            },
-            {
-                name: 'outputDir',
-                type: 'string',
-                required: false,
-                description: 'Output directory for configuration files',
-                default: '.',
-            },
-        ],
-    },
-    {
-        name: 'get_workflow_guide',
-        description: 'Get recommended workflows and best practices for using code auditor tools effectively',
-        parameters: [
-            {
-                name: 'scenario',
-                type: 'string',
-                required: false,
-                description: 'Specific scenario: initial-setup, react-development, code-review, find-patterns, maintenance. Leave empty to see all.',
-            },
-        ],
-    },
-    // Analyzer Configuration Tools
-    {
-        name: 'set_analyzer_config',
-        description: 'Set or update analyzer configuration that persists across audit runs',
-        parameters: [
-            {
-                name: 'analyzerName',
-                type: 'string',
-                required: true,
-                description: 'The analyzer to configure (solid, dry, security, etc.)',
-            },
-            {
-                name: 'config',
-                type: 'object',
-                required: true,
-                description: 'Configuration object for the analyzer (e.g., thresholds, rules)',
-            },
-            {
-                name: 'projectPath',
-                type: 'string',
-                required: false,
-                description: 'Optional project path for project-specific config (defaults to global)',
-            },
-        ],
-    },
-    {
-        name: 'get_analyzer_config',
-        description: 'Get current configuration for an analyzer',
-        parameters: [
-            {
-                name: 'analyzerName',
-                type: 'string',
-                required: false,
-                description: 'Specific analyzer name, or omit to get all configs',
-            },
-            {
-                name: 'projectPath',
-                type: 'string',
-                required: false,
-                description: 'Optional project path to get project-specific config',
-            },
-        ],
-    },
-    {
-        name: 'reset_analyzer_config',
-        description: 'Reset analyzer configuration to defaults',
-        parameters: [
-            {
-                name: 'analyzerName',
-                type: 'string',
-                required: false,
-                description: 'Specific analyzer to reset, or omit to reset all',
-            },
-            {
-                name: 'projectPath',
-                type: 'string',
-                required: false,
-                description: 'Optional project path to reset only project-specific config',
-            },
-        ],
-    },
-    {
-        name: 'whitelist_get',
-        description: 'Get current whitelist entries for dependency and class instantiation checks',
-        parameters: [
-            {
-                name: 'type',
-                type: 'string',
-                required: false,
-                description: 'Filter by type: platform-api, framework-class, project-dep, shared-library, node-builtin',
-                enum: ['platform-api', 'framework-class', 'project-dep', 'shared-library', 'node-builtin'],
-            },
-            {
-                name: 'status',
-                type: 'string',
-                required: false,
-                description: 'Filter by status: active, pending, rejected, disabled',
-                enum: ['active', 'pending', 'rejected', 'disabled'],
-            },
-        ],
-    },
-    {
-        name: 'whitelist_add',
-        description: 'Add a new entry to the whitelist',
-        parameters: [
-            {
-                name: 'name',
-                type: 'string',
-                required: true,
-                description: 'Class name or import path to whitelist',
-            },
-            {
-                name: 'type',
-                type: 'string',
-                required: true,
-                description: 'Type of whitelist entry',
-                enum: ['platform-api', 'framework-class', 'project-dep', 'shared-library', 'node-builtin'],
-            },
-            {
-                name: 'description',
-                type: 'string',
-                required: false,
-                description: 'Explanation of why this is whitelisted',
-            },
-            {
-                name: 'patterns',
-                type: 'array',
-                required: false,
-                description: 'Additional patterns to match (e.g., ["fs/*", "node:fs"])',
-            },
-        ],
-    },
-    {
-        name: 'whitelist_update_status',
-        description: 'Update the status of a whitelist entry',
-        parameters: [
-            {
-                name: 'name',
-                type: 'string',
-                required: true,
-                description: 'Name of the whitelist entry to update',
-            },
-            {
-                name: 'status',
-                type: 'string',
-                required: true,
-                description: 'New status for the entry',
-                enum: ['active', 'pending', 'rejected', 'disabled'],
-            },
-        ],
-    },
-    {
-        name: 'whitelist_detect',
-        description: 'Detect potential whitelist candidates from package.json and usage patterns',
-        parameters: [
-            {
-                name: 'path',
-                type: 'string',
-                required: false,
-                description: 'Project path to analyze (defaults to current directory)',
-                default: process.cwd(),
-            },
-            {
-                name: 'includePackageJson',
-                type: 'boolean',
-                required: false,
-                description: 'Include dependencies from package.json',
-                default: true,
-            },
-            {
-                name: 'autoPopulate',
-                type: 'boolean',
-                required: false,
-                description: 'Automatically add high-confidence entries (>95% confidence)',
-                default: false,
-            },
-        ],
-    },
-    {
-        name: 'project_tasks',
-        description: 'Manage a persistent per-project task queue. Tasks and analyzer configs survive sync_index reset; reset clears function index, cached audits, code maps, and schema overlays. Use delete to remove a task.',
-        parameters: [
-            {
-                name: 'action',
-                type: 'string',
-                required: true,
-                description: 'list | list_tree | create | get | update | complete_task | delete. list/list_tree/create use projectPath or default to process.cwd(); create needs title; get/update/complete_task/delete need taskId; update needs patch object.',
-                enum: [
-                    'list',
-                    'list_tree',
-                    'create',
-                    'get',
-                    'update',
-                    'complete_task',
-                    'delete'
-                ],
-            },
-            {
-                name: 'projectPath',
-                type: 'string',
-                required: false,
-                description: 'Project root (resolved). Omit to use the MCP server working directory; response includes projectPathDefaulted when omitted.',
-            },
-            {
-                name: 'taskId',
-                type: 'string',
-                required: false,
-                description: 'Stable task id (UUID). Required for get, update, complete_task, delete.',
-            },
-            {
-                name: 'title',
-                type: 'string',
-                required: false,
-                description: 'Task title. Required for create.',
-            },
-            {
-                name: 'description',
-                type: 'string',
-                required: false,
-                description: 'Longer description / notes.',
-            },
-            {
-                name: 'status',
-                type: 'string',
-                required: false,
-                description: 'pending | in_progress | blocked | done | cancelled. Filter for list; initial status for create; can be set via update patch.',
-                enum: ['pending', 'in_progress', 'blocked', 'done', 'cancelled'],
-            },
-            {
-                name: 'priority',
-                type: 'string',
-                required: false,
-                description: 'Optional priority for create/update patch.',
-                enum: ['low', 'medium', 'high'],
-            },
-            {
-                name: 'labels',
-                type: 'array',
-                required: false,
-                description: 'String tags (e.g. ["audit","refactor"]).',
-            },
-            {
-                name: 'metadata',
-                type: 'object',
-                required: false,
-                description: 'Arbitrary JSON object: related file paths, links, audit IDs, etc.',
-            },
-            {
-                name: 'parentTaskId',
-                type: 'string',
-                required: false,
-                description: 'Optional parent task for subtasks.',
-            },
-            {
-                name: 'source',
-                type: 'string',
-                required: false,
-                description: 'manual | audit | mcp. Filter for list; provenance for create; can be set via update patch.',
-                enum: ['manual', 'audit', 'mcp'],
-            },
-            {
-                name: 'blockedBy',
-                type: 'array',
-                required: false,
-                description: 'Task IDs this item is blocked by (waiting-on).',
-            },
-            {
-                name: 'label',
-                type: 'string',
-                required: false,
-                description: 'Filter/search by label value.',
-            },
-            {
-                name: 'blockedByTaskId',
-                type: 'string',
-                required: false,
-                description: 'Filter tasks blocked by this task ID.',
-            },
-            {
-                name: 'query',
-                type: 'string',
-                required: false,
-                description: 'Case-insensitive text search across title/description/labels/files/symbols.',
-            },
-            {
-                name: 'hasChildren',
-                type: 'boolean',
-                required: false,
-                description: 'Filter tasks that do/do not have direct subtasks.',
-            },
-            {
-                name: 'overdueOnly',
-                type: 'boolean',
-                required: false,
-                description: 'Filter tasks with dueAt in the past and not closed.',
-            },
-            {
-                name: 'actionableOnly',
-                type: 'boolean',
-                required: false,
-                description: 'Filter tasks that are open and unblocked by open dependencies.',
-            },
-            {
-                name: 'dueAt',
-                type: 'string',
-                required: false,
-                description: 'ISO 8601 due datetime for create; omit or null in patch to clear.',
-            },
-            {
-                name: 'sortOrder',
-                type: 'number',
-                required: false,
-                description: 'Lower numbers sort first within a project (default 0).',
-            },
-            {
-                name: 'relatedFiles',
-                type: 'array',
-                required: false,
-                description: 'Repo-relative or absolute file paths tied to the task.',
-            },
-            {
-                name: 'relatedSymbols',
-                type: 'array',
-                required: false,
-                description: 'Function, class, or component names for cross-linking.',
-            },
-            {
-                name: 'patch',
-                type: 'object',
-                required: false,
-                description: 'For update: partial fields (title, description, status, priority, labels, metadata, parentTaskId, source, blockedBy, dueAt, sortOrder, relatedFiles, relatedSymbols).',
-            },
-            {
-                name: 'limit',
-                type: 'number',
-                required: false,
-                description: 'Max tasks to return for list (default 500, max 1000).',
-            },
-            {
-                name: 'mode',
-                type: 'string',
-                required: false,
-                description: 'Delete mode: reject (default), detach subtasks, or cascade descendants.',
-                enum: ['reject', 'detach', 'cascade'],
-            },
-        ],
-    },
-];
-function getAllViolations(result) {
-    const violations = [];
-    for (const [analyzerName, analyzerResult] of Object.entries(result.analyzerResults)) {
-        for (const violation of analyzerResult.violations) {
-            violations.push({
-                ...violation,
-                analyzer: analyzerName,
-            });
-        }
-    }
-    return violations;
-}
-function calculateHealthScore(result) {
-    const filesAnalyzed = result.metadata?.filesAnalyzed || 1;
-    const critical = result.summary.criticalIssues || 0;
-    const warnings = result.summary.warnings || 0;
-    const suggestions = result.summary.suggestions || 0;
-    // Weight factors for different severity levels
-    const weights = {
-        critical: 10,
-        warning: 3,
-        suggestion: 0.5
-    };
-    // Calculate weighted violations per file
-    const weightedViolations = (critical * weights.critical) +
-        (warnings * weights.warning) +
-        (suggestions * weights.suggestion);
-    const violationsPerFile = weightedViolations / filesAnalyzed;
-    // Score calculation: 100 points minus deductions
-    // Each weighted violation per file reduces score
-    // Critical-heavy codebases drop faster than suggestion-heavy ones
-    let score = 100 - (violationsPerFile * 2);
-    return Math.max(0, Math.round(Math.min(100, score)));
-}
-class RequestAbortedError extends Error {
-    constructor(message = 'MCP request aborted') {
-        super(message);
-        this.name = 'RequestAbortedError';
-    }
-}
-function throwIfRequestAborted(signal, phase) {
-    if (!signal?.aborted) {
-        return;
-    }
-    throw new RequestAbortedError(`Request aborted${phase ? ` during ${phase}` : ''}`);
-}
-async function withAbortSignal(signal, phase, op) {
-    throwIfRequestAborted(signal, phase);
-    if (!signal) {
-        return op();
-    }
-    return await new Promise((resolve, reject) => {
-        const onAbort = () => reject(new RequestAbortedError(`Request aborted during ${phase}`));
-        signal.addEventListener('abort', onAbort, { once: true });
-        void op()
-            .then(resolve)
-            .catch(reject)
-            .finally(() => {
-            signal.removeEventListener('abort', onAbort);
-        });
-    });
-}
-function serializeForMcp(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch (error) {
-        return JSON.stringify({
-            success: false,
-            error: `Failed to serialize MCP response: ${error instanceof Error ? error.message : String(error)}`
-        });
-    }
-}
-function safeJson(value) {
-    try {
-        return JSON.stringify(value, null, 2);
-    }
-    catch (error) {
-        return `[unserializable: ${error instanceof Error ? error.message : String(error)}]`;
-    }
-}
-function registerProcessReliabilityHandlers() {
-    const g = globalThis;
-    const exitOnFatal = process.env.CODE_AUDITOR_EXIT_ON_FATAL === '1' ||
-        process.env.CODE_AUDITOR_EXIT_ON_FATAL === 'true';
-    if (!g.__codeAuditorUncaughtExceptionHandlerInstalled) {
-        process.on('uncaughtException', (error) => {
-            console.error(chalk.red('[ERROR]'), 'Uncaught exception:', error);
-            console.error(chalk.red('[ERROR]'), 'Stack:', error.stack);
-            console.error(chalk.red('[ERROR]'), 'Error details:', safeJson(error));
-            if (exitOnFatal) {
-                process.exit(1);
-            }
-        });
-        g.__codeAuditorUncaughtExceptionHandlerInstalled = true;
-    }
-    if (!g.__codeAuditorUnhandledRejectionHandlerInstalled) {
-        process.on('unhandledRejection', (reason, promise) => {
-            console.error(chalk.red('[ERROR]'), 'Unhandled rejection at:', promise);
-            console.error(chalk.red('[ERROR]'), 'Reason:', reason);
-            console.error(chalk.red('[ERROR]'), 'Rejection details:', safeJson(reason));
-            if (exitOnFatal) {
-                process.exit(1);
-            }
-        });
-        g.__codeAuditorUnhandledRejectionHandlerInstalled = true;
-    }
-}
-async function startMcpServer() {
-    logMcpInfo('startup', `code-auditor-mcp ${PACKAGE_VERSION} (standalone stdio)`, {
-        pid: process.pid,
-        cwd: process.cwd(),
-        dataDir: process.env.CODE_AUDITOR_DATA_DIR ?? '(default)'
-    });
-    mcpDebugStderr(chalk.blue('[DEBUG]'), `Node ${process.version} · cwd ${process.cwd()}`);
-    const server = new Server({
-        name: 'code-auditor',
-        version: PACKAGE_VERSION,
-    }, {
-        capabilities: {
-            tools: {},
-        },
-    });
-    // Add error handler
-    server.onerror = (error) => {
-        console.error(chalk.red('[ERROR]'), 'Server error occurred:', error);
-        console.error(chalk.red('[ERROR]'), 'Error stack:', error.stack);
-    };
-    server.setRequestHandler(ListToolsRequestSchema, async (request) => {
-        mcpTraceStderr(chalk.blue('[DEBUG]'), 'ListTools', JSON.stringify(request, null, 2));
-        const response = {
-            tools: tools.map(tool => ({
-                name: tool.name,
-                description: tool.description,
-                inputSchema: {
-                    type: 'object',
-                    properties: tool.parameters.reduce((acc, param) => {
-                        acc[param.name] = {
-                            type: param.type,
-                            description: param.description,
-                            ...(param.default !== undefined && { default: param.default }),
-                            ...(param.enum && { enum: param.enum }),
-                        };
-                        return acc;
-                    }, {}),
-                    required: tool.parameters.filter(p => p.required).map(p => p.name),
-                },
-            })),
-        };
-        mcpTraceStderr(chalk.blue('[DEBUG]'), `ListTools → ${response.tools.length} tools`);
-        return response;
-    });
-    server.setRequestHandler(InitializeRequestSchema, async (request) => {
-        mcpTraceStderr(chalk.blue('[DEBUG]'), 'initialize', JSON.stringify(request, null, 2));
-        const response = {
-            protocolVersion: '2024-11-05',
-            capabilities: {
-                tools: {},
-            },
-            serverInfo: {
-                name: 'code-auditor',
-                version: PACKAGE_VERSION,
-            },
-        };
-        mcpTraceStderr(chalk.blue('[DEBUG]'), 'initialize response', JSON.stringify(response, null, 2));
-        return response;
-    });
-    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-        const { name, arguments: args } = request.params;
-        mcpTraceStderr(chalk.blue('[DEBUG]'), `CallTool ${name}`, JSON.stringify({
-            argKeys: args && typeof args === 'object' ? Object.keys(args) : [],
-            hasArgs: !!args
-        }));
-        const requestSignal = extra?.signal;
-        try {
-            let result;
-            throwIfRequestAborted(requestSignal, `start ${name}`);
-            switch (name) {
-                case 'start_audit': {
-                    result = await withAbortSignal(requestSignal, 'start_audit', () => startAuditJob(args, {
-                        defaultAnalyzers: ['solid', 'dry'],
-                        defaultMinSeverity: 'warning',
-                        defaultGenerateCodeMap: false,
-                    }));
-                    break;
-                }
-                case 'audit_status': {
-                    const jobId = args.jobId;
-                    if (!jobId) {
-                        throw new Error('audit_status requires jobId');
-                    }
-                    result = getAuditJobStatus(jobId);
-                    break;
-                }
-                case 'audit_results': {
-                    result = await withAbortSignal(requestSignal, 'audit_results', () => getAuditResultsPage(args));
-                    break;
-                }
-                case 'audit': {
-                    result = await withAbortSignal(requestSignal, 'audit', () => getAuditResultsPage(args));
-                    break;
-                }
-                case 'audit_health': {
-                    const auditPath = path.resolve(args.path || process.cwd());
-                    await assertAuditPathExists(auditPath);
-                    const indexFunctions = args.indexFunctions !== false; // Default true
-                    // Get stored analyzer configs from database
-                    const db = CodeIndexDB.getInstance();
-                    await db.initialize();
-                    const storedConfigs = await db.getAllAnalyzerConfigs(auditPath);
-                    // Merge stored configs with any provided configs
-                    const analyzerConfigs = {
-                        ...storedConfigs,
-                        ...(args.analyzerConfigs || {})
-                    };
-                    const runner = createAuditRunner({
-                        projectRoot: auditPath,
-                        enabledAnalyzers: ['solid', 'dry'],
-                        minSeverity: 'warning',
-                        verbose: false,
-                        indexFunctions, // Pass the flag to the runner
-                        ...(Object.keys(analyzerConfigs).length > 0 && { analyzerConfigs }),
-                    });
-                    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
-                            };
-                            mcpDebugStderr(chalk.blue('[INFO]'), `Synced functions: ${syncStats.added} added, ${syncStats.updated} updated, ${syncStats.removed} removed`);
-                        }
-                        catch (error) {
-                            console.error(chalk.yellow('[WARN]'), 'Failed to index functions:', error);
-                        }
-                    }
-                    const threshold = args.threshold || 70;
-                    result = {
-                        healthScore,
-                        threshold,
-                        passed: healthScore >= threshold,
-                        status: healthScore >= threshold ? 'healthy' : 'needs-attention',
-                        metrics: {
-                            filesAnalyzed: auditResult.metadata.filesAnalyzed,
-                            totalViolations: auditResult.summary.totalViolations,
-                            criticalViolations: auditResult.summary.criticalIssues,
-                            warningViolations: auditResult.summary.warnings,
-                        },
-                        recommendation: healthScore >= 90 ? 'Excellent code health!' :
-                            healthScore >= 70 ? 'Good code health with room for improvement' :
-                                'Code health needs attention - run detailed audit',
-                        ...(indexingResult && { functionIndexing: indexingResult }),
-                    };
-                    break;
-                }
-                case 'search_code': {
-                    const query = args.query;
-                    const filters = args.filters;
-                    const limit = args.limit || 50;
-                    const offset = args.offset || 0;
-                    // Extract searchMode from filters if present
-                    let searchMode;
-                    if (filters && filters.searchMode) {
-                        searchMode = filters.searchMode;
-                        // Remove searchMode from filters as it's a top-level option
-                        const { searchMode: _, ...cleanFilters } = filters;
-                        result = await searchFunctions({ query, filters: cleanFilters, limit, offset, searchMode });
-                    }
-                    else {
-                        result = await searchFunctions({ query, filters, limit, offset });
-                    }
-                    break;
-                }
-                case 'find_definition': {
-                    const name = args.name;
-                    const filePath = args.filePath;
-                    const definition = await findDefinition(name, filePath);
-                    result = definition || { error: 'Function not found' };
-                    break;
-                }
-                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 = {
-                                success: true,
-                                mode: 'cleanup',
-                                filesProcessed: cleanupResult.scannedCount,
-                                functionsRemoved: cleanupResult.removedCount,
-                                message: `Removed ${cleanupResult.removedCount} functions from ${cleanupResult.removedFiles.length} deleted files`
-                            };
-                            break;
-                        }
-                        case 'sync': {
-                            let syncResult;
-                            if (targetPath) {
-                                const functions = await scanFunctionsInDirectory(targetPath);
-                                syncResult = await syncFileIndex(targetPath, functions);
-                                result = {
-                                    success: true,
-                                    mode: 'sync',
-                                    path: targetPath,
-                                    ...syncResult
-                                };
-                            }
-                            else {
-                                syncResult = await db.deepSync();
-                                result = {
-                                    success: true,
-                                    mode: 'sync',
-                                    filesProcessed: syncResult.syncedFiles,
-                                    functionsAdded: syncResult.addedFunctions,
-                                    functionsUpdated: syncResult.updatedFunctions,
-                                    functionsRemoved: syncResult.removedFunctions
-                                };
-                            }
-                            // Auto-detect and populate whitelist entries
-                            try {
-                                const { WhitelistService } = await import('./services/whitelistService.js');
-                                const whitelistService = WhitelistService.getInstance();
-                                const whitelistResult = await whitelistService.whitelistAllDependencies(targetPath || process.cwd());
-                                if (whitelistResult.added > 0) {
-                                    result.whitelistAdded = whitelistResult.added;
-                                    result.whitelistMessage = `Auto-added ${whitelistResult.added} whitelist entries`;
-                                }
-                            }
-                            catch (error) {
-                                // Don't fail sync if whitelist detection fails
-                                console.warn('Whitelist auto-detection failed:', error);
-                            }
-                            break;
-                        }
-                        case 'reset': {
-                            await clearIndex();
-                            result = {
-                                success: true,
-                                mode: 'reset',
-                                message: 'Analysis-derived data cleared (functions, search index, cached audits, code maps, schemas). Project tasks, whitelist, and analyzer configs were preserved.'
-                            };
-                            break;
-                        }
-                        default:
-                            throw new Error(`Unknown sync mode: ${mode}`);
-                    }
-                    break;
-                }
-                case 'generate_ai_config': {
-                    const tools = args.tools;
-                    const outputDir = args.outputDir || '.';
-                    if (!Array.isArray(tools) || tools.length === 0) {
-                        throw new Error('tools parameter is required and must be a non-empty array');
-                    }
-                    const factory = new ConfigGeneratorFactory();
-                    const generatedFiles = [];
-                    const errors = [];
-                    for (const toolName of tools) {
-                        try {
-                            const generator = factory.createGenerator(toolName);
-                            if (!generator) {
-                                errors.push(`Unknown tool: ${toolName}`);
-                                continue;
-                            }
-                            const config = generator.generateConfig();
-                            const outputPath = path.join(outputDir, config.filename);
-                            // Check if file exists
-                            const fs = await import('fs/promises');
-                            try {
-                                await fs.access(outputPath);
-                                errors.push(`File already exists: ${config.filename} (use overwrite: true to replace)`);
-                                continue;
-                            }
-                            catch {
-                                // File doesn't exist, proceed
-                            }
-                            await fs.writeFile(outputPath, config.content, 'utf8');
-                            generatedFiles.push(config.filename);
-                        }
-                        catch (error) {
-                            errors.push(`Failed to generate config for ${toolName}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                        }
-                    }
-                    result = {
-                        success: errors.length === 0,
-                        generatedFiles,
-                        ...(errors.length > 0 && { errors }),
-                        totalRequested: tools.length,
-                        totalGenerated: generatedFiles.length
-                    };
-                    break;
-                }
-                case 'get_workflow_guide': {
-                    const scenario = args.scenario;
-                    const { getWorkflowGuide, getWorkflowTips } = await import('./mcp-tools/workflowGuide.js');
-                    try {
-                        const workflows = getWorkflowGuide(scenario);
-                        const tips = getWorkflowTips();
-                        result = {
-                            success: true,
-                            ...(scenario ? { workflow: workflows } : { workflows }),
-                            tips
-                        };
-                    }
-                    catch (error) {
-                        result = {
-                            success: false,
-                            error: error instanceof Error ? error.message : 'Unknown error',
-                            availableScenarios: ['initial-setup', 'react-development', 'code-review', 'find-patterns', 'maintenance', 'analyzer-configuration']
-                        };
-                    }
-                    break;
-                }
-                case 'set_analyzer_config': {
-                    const analyzerName = args.analyzerName;
-                    const config = args.config;
-                    const projectPath = args.projectPath;
-                    const db = CodeIndexDB.getInstance();
-                    await db.initialize();
-                    try {
-                        await db.storeAnalyzerConfig(analyzerName, config, {
-                            projectPath,
-                            isGlobal: !projectPath
-                        });
-                        result = {
-                            success: true,
-                            message: `Configuration for ${analyzerName} analyzer has been saved${projectPath ? ` for project ${projectPath}` : ' globally'}`,
-                            analyzer: analyzerName,
-                            scope: projectPath ? 'project' : 'global',
-                            config
-                        };
-                    }
-                    catch (error) {
-                        result = {
-                            success: false,
-                            error: error instanceof Error ? error.message : 'Failed to save configuration'
-                        };
-                    }
-                    break;
-                }
-                case 'get_analyzer_config': {
-                    const analyzerName = args.analyzerName;
-                    const projectPath = args.projectPath;
-                    const db = CodeIndexDB.getInstance();
-                    await db.initialize();
-                    try {
-                        if (analyzerName) {
-                            const config = await db.getAnalyzerConfig(analyzerName, projectPath);
-                            result = {
-                                success: true,
-                                analyzer: analyzerName,
-                                config: config || null,
-                                scope: projectPath ? 'project' : 'global',
-                                message: config ? 'Configuration found' : 'No custom configuration found, using defaults'
-                            };
-                        }
-                        else {
-                            const configs = await db.getAllAnalyzerConfigs(projectPath);
-                            result = {
-                                success: true,
-                                configs,
-                                scope: projectPath ? 'project' : 'global',
-                                message: `Found ${Object.keys(configs).length} analyzer configurations`
-                            };
-                        }
-                    }
-                    catch (error) {
-                        result = {
-                            success: false,
-                            error: error instanceof Error ? error.message : 'Failed to get configuration'
-                        };
-                    }
-                    break;
-                }
-                case 'reset_analyzer_config': {
-                    const analyzerName = args.analyzerName;
-                    const projectPath = args.projectPath;
-                    const db = CodeIndexDB.getInstance();
-                    await db.initialize();
-                    try {
-                        if (analyzerName) {
-                            const deleted = await db.deleteAnalyzerConfig(analyzerName, {
-                                projectPath,
-                                isGlobal: !projectPath
-                            });
-                            result = {
-                                success: deleted,
-                                message: deleted
-                                    ? `Configuration for ${analyzerName} analyzer has been reset${projectPath ? ` for project ${projectPath}` : ' globally'}`
-                                    : `No configuration found for ${analyzerName} analyzer`,
-                                analyzer: analyzerName,
-                                scope: projectPath ? 'project' : 'global'
-                            };
-                        }
-                        else {
-                            await db.resetAnalyzerConfigs(projectPath);
-                            result = {
-                                success: true,
-                                message: projectPath
-                                    ? `All project-specific configurations for ${projectPath} have been reset`
-                                    : 'All analyzer configurations have been reset to defaults',
-                                scope: projectPath ? 'project' : 'global'
-                            };
-                        }
-                    }
-                    catch (error) {
-                        result = {
-                            success: false,
-                            error: error instanceof Error ? error.message : 'Failed to reset configuration'
-                        };
-                    }
-                    break;
-                }
-                case 'whitelist_get': {
-                    const { handleWhitelistGet } = await import('./mcp-tools/whitelistTools.js');
-                    result = await handleWhitelistGet(args);
-                    break;
-                }
-                case 'whitelist_add': {
-                    const { handleWhitelistAdd } = await import('./mcp-tools/whitelistTools.js');
-                    result = await handleWhitelistAdd(args);
-                    break;
-                }
-                case 'whitelist_update_status': {
-                    const { handleWhitelistUpdateStatus } = await import('./mcp-tools/whitelistTools.js');
-                    result = await handleWhitelistUpdateStatus(args);
-                    break;
-                }
-                case 'whitelist_detect': {
-                    const { handleWhitelistDetect } = await import('./mcp-tools/whitelistTools.js');
-                    result = await handleWhitelistDetect(args);
-                    break;
-                }
-                case 'project_tasks': {
-                    const { handleProjectTasks } = await import('./mcp-tools/projectTasks.js');
-                    result = await withAbortSignal(requestSignal, 'project_tasks', () => handleProjectTasks((args || {}), {
-                        signal: requestSignal
-                    }));
-                    break;
-                }
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-            const response = {
-                content: [
-                    {
-                        type: 'text',
-                        text: serializeForMcp(result),
-                    },
-                ],
-            };
-            mcpTraceStderr(chalk.blue('[DEBUG]'), `Tool ${name} ok`, `responseBytes=${response.content[0].text.length}`);
-            throwIfRequestAborted(requestSignal, `before response ${name}`);
-            return response;
-        }
-        catch (error) {
-            if (error instanceof RequestAbortedError) {
-                throw error;
-            }
-            console.error(chalk.red('[ERROR]'), `Tool ${name} execution failed:`, error);
-            console.error(chalk.red('[ERROR]'), 'Error stack:', error instanceof Error ? error.stack : 'No stack trace');
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: serializeForMcp(formatMcpToolErrorPayload(name, error)),
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    const transport = new StdioServerTransport();
-    // Add transport event handlers if available
-    if (transport.onclose) {
-        transport.onclose = () => {
-            console.error(chalk.yellow('[WARN]'), 'Transport closed');
-        };
-    }
-    if (transport.onerror) {
-        transport.onerror = (error) => {
-            console.error(chalk.red('[ERROR]'), 'Transport error:', error);
-        };
-    }
-    await server.connect(transport);
-    console.error(chalk.green('✓ Code Auditor MCP Server started (standalone mode)'));
-    console.error(chalk.gray(`Listening on stdio · ${tools.length} tools · ${PACKAGE_VERSION}`));
-    mcpDebugStderr(chalk.blue('[DEBUG]'), 'Server ready', {
-        name: 'code-auditor',
-        transport: 'stdio',
-        toolCount: tools.length
-    });
-}
-registerProcessReliabilityHandlers();
-// Add SIGTERM and SIGINT handlers
-process.on('SIGTERM', () => {
-    console.error(chalk.yellow('[WARN]'), 'Received SIGTERM, shutting down gracefully...');
-    process.exitCode = 0;
-});
-process.on('SIGINT', () => {
-    console.error(chalk.yellow('[WARN]'), 'Received SIGINT, shutting down gracefully...');
-    process.exitCode = 0;
-});
-// Log when stdin/stdout events occur
-process.stdin.on('error', (error) => {
-    console.error(chalk.red('[ERROR]'), 'stdin error:', error);
-});
-process.stdout.on('error', (error) => {
-    console.error(chalk.red('[ERROR]'), 'stdout error:', error);
-});
-startMcpServer().catch(error => {
-    console.error(chalk.red('[ERROR]'), 'Failed to start MCP server:', error);
-    console.error(chalk.red('[ERROR]'), 'Stack:', error.stack);
-    process.exitCode = 1;
-});
-//# sourceMappingURL=mcp-standalone.js.map