thaddeus 1.0.26 → 1.0.28

package/src/services/lsp/LSPClient.js

@@ -0,0 +1,306 @@
+import { spawn } from 'child_process';
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter, Trace, } from 'vscode-jsonrpc/node.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { errorMessage } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { subprocessEnv } from '../../utils/subprocessEnv.js';
+/**
+ * Create an LSP client wrapper using vscode-jsonrpc.
+ * Manages communication with an LSP server process via stdio.
+ *
+ * @param onCrash - Called when the server process exits unexpectedly (non-zero
+ *   exit code during operation, not during intentional stop). Allows the owner
+ *   to propagate crash state so the server can be restarted on next use.
+ */
+export function createLSPClient(serverName, onCrash) {
+    // State variables in closure
+    let process;
+    let connection;
+    let capabilities;
+    let isInitialized = false;
+    let startFailed = false;
+    let startError;
+    let isStopping = false; // Track intentional shutdown to avoid spurious error logging
+    // Queue handlers registered before connection ready (lazy initialization support)
+    const pendingHandlers = [];
+    const pendingRequestHandlers = [];
+    function checkStartFailed() {
+        if (startFailed) {
+            throw startError || new Error(`LSP server ${serverName} failed to start`);
+        }
+    }
+    return {
+        get capabilities() {
+            return capabilities;
+        },
+        get isInitialized() {
+            return isInitialized;
+        },
+        async start(command, args, options) {
+            try {
+                // 1. Spawn LSP server process
+                process = spawn(command, args, {
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    env: { ...subprocessEnv(), ...options?.env },
+                    cwd: options?.cwd,
+                    // Prevent visible console window on Windows (no-op on other platforms)
+                    windowsHide: true,
+                });
+                if (!process.stdout || !process.stdin) {
+                    throw new Error('LSP server process stdio not available');
+                }
+                // 1.5. Wait for process to successfully spawn before using streams
+                // This is CRITICAL: spawn() returns immediately, but the 'error' event
+                // (e.g., ENOENT for command not found) fires asynchronously.
+                // If we use the streams before confirming spawn succeeded, we get
+                // unhandled promise rejections when writes fail on invalid streams.
+                const spawnedProcess = process; // Capture for closure
+                await new Promise((resolve, reject) => {
+                    const onSpawn = () => {
+                        cleanup();
+                        resolve();
+                    };
+                    const onError = (error) => {
+                        cleanup();
+                        reject(error);
+                    };
+                    const cleanup = () => {
+                        spawnedProcess.removeListener('spawn', onSpawn);
+                        spawnedProcess.removeListener('error', onError);
+                    };
+                    spawnedProcess.once('spawn', onSpawn);
+                    spawnedProcess.once('error', onError);
+                });
+                // Capture stderr for server diagnostics and errors
+                if (process.stderr) {
+                    process.stderr.on('data', (data) => {
+                        const output = data.toString().trim();
+                        if (output) {
+                            logForDebugging(`[LSP SERVER ${serverName}] ${output}`);
+                        }
+                    });
+                }
+                // Handle process errors (after successful spawn, e.g., crash during operation)
+                process.on('error', error => {
+                    if (!isStopping) {
+                        startFailed = true;
+                        startError = error;
+                        logError(new Error(`LSP server ${serverName} failed to start: ${error.message}`));
+                    }
+                });
+                process.on('exit', (code, _signal) => {
+                    if (code !== 0 && code !== null && !isStopping) {
+                        isInitialized = false;
+                        startFailed = false;
+                        startError = undefined;
+                        const crashError = new Error(`LSP server ${serverName} crashed with exit code ${code}`);
+                        logError(crashError);
+                        onCrash?.(crashError);
+                    }
+                });
+                // Handle stdin stream errors to prevent unhandled promise rejections
+                // when the LSP server process exits before we finish writing
+                process.stdin.on('error', (error) => {
+                    if (!isStopping) {
+                        logForDebugging(`LSP server ${serverName} stdin error: ${error.message}`);
+                    }
+                    // Error is logged but not thrown - the connection error handler will catch this
+                });
+                // 2. Create JSON-RPC connection
+                const reader = new StreamMessageReader(process.stdout);
+                const writer = new StreamMessageWriter(process.stdin);
+                connection = createMessageConnection(reader, writer);
+                // 2.5. Register error/close handlers BEFORE listen() to catch all errors
+                // This prevents unhandled promise rejections when the server crashes or closes unexpectedly
+                connection.onError(([error, _message, _code]) => {
+                    // Only log if not intentionally stopping (avoid spurious errors during shutdown)
+                    if (!isStopping) {
+                        startFailed = true;
+                        startError = error;
+                        logError(new Error(`LSP server ${serverName} connection error: ${error.message}`));
+                    }
+                });
+                connection.onClose(() => {
+                    // Only treat as error if not intentionally stopping
+                    if (!isStopping) {
+                        isInitialized = false;
+                        // Don't set startFailed here - the connection may close after graceful shutdown
+                        logForDebugging(`LSP server ${serverName} connection closed`);
+                    }
+                });
+                // 3. Start listening for messages
+                connection.listen();
+                // 3.5. Enable protocol tracing for debugging
+                // Note: trace() sends a $/setTrace notification which can fail if the server
+                // process has already exited. We catch and log the error rather than letting
+                // it become an unhandled promise rejection.
+                connection
+                    .trace(Trace.Verbose, {
+                    log: (message) => {
+                        logForDebugging(`[LSP PROTOCOL ${serverName}] ${message}`);
+                    },
+                })
+                    .catch((error) => {
+                    logForDebugging(`Failed to enable tracing for ${serverName}: ${error.message}`);
+                });
+                // 4. Apply any queued notification handlers
+                for (const { method, handler } of pendingHandlers) {
+                    connection.onNotification(method, handler);
+                    logForDebugging(`Applied queued notification handler for ${serverName}.${method}`);
+                }
+                pendingHandlers.length = 0; // Clear the queue
+                // 5. Apply any queued request handlers
+                for (const { method, handler } of pendingRequestHandlers) {
+                    connection.onRequest(method, handler);
+                    logForDebugging(`Applied queued request handler for ${serverName}.${method}`);
+                }
+                pendingRequestHandlers.length = 0; // Clear the queue
+                logForDebugging(`LSP client started for ${serverName}`);
+            }
+            catch (error) {
+                const err = error;
+                logError(new Error(`LSP server ${serverName} failed to start: ${err.message}`));
+                throw error;
+            }
+        },
+        async initialize(params) {
+            if (!connection) {
+                throw new Error('LSP client not started');
+            }
+            checkStartFailed();
+            try {
+                const result = await connection.sendRequest('initialize', params);
+                capabilities = result.capabilities;
+                // Send initialized notification
+                await connection.sendNotification('initialized', {});
+                isInitialized = true;
+                logForDebugging(`LSP server ${serverName} initialized`);
+                return result;
+            }
+            catch (error) {
+                const err = error;
+                logError(new Error(`LSP server ${serverName} initialize failed: ${err.message}`));
+                throw error;
+            }
+        },
+        async sendRequest(method, params) {
+            if (!connection) {
+                throw new Error('LSP client not started');
+            }
+            checkStartFailed();
+            if (!isInitialized) {
+                throw new Error('LSP server not initialized');
+            }
+            try {
+                return await connection.sendRequest(method, params);
+            }
+            catch (error) {
+                const err = error;
+                logError(new Error(`LSP server ${serverName} request ${method} failed: ${err.message}`));
+                throw error;
+            }
+        },
+        async sendNotification(method, params) {
+            if (!connection) {
+                throw new Error('LSP client not started');
+            }
+            checkStartFailed();
+            try {
+                await connection.sendNotification(method, params);
+            }
+            catch (error) {
+                const err = error;
+                logError(new Error(`LSP server ${serverName} notification ${method} failed: ${err.message}`));
+                // Don't re-throw for notifications - they're fire-and-forget
+                logForDebugging(`Notification ${method} failed but continuing`);
+            }
+        },
+        onNotification(method, handler) {
+            if (!connection) {
+                // Queue handler for application when connection is ready (lazy initialization)
+                pendingHandlers.push({ method, handler });
+                logForDebugging(`Queued notification handler for ${serverName}.${method} (connection not ready)`);
+                return;
+            }
+            checkStartFailed();
+            connection.onNotification(method, handler);
+        },
+        onRequest(method, handler) {
+            if (!connection) {
+                // Queue handler for application when connection is ready (lazy initialization)
+                pendingRequestHandlers.push({
+                    method,
+                    handler: handler,
+                });
+                logForDebugging(`Queued request handler for ${serverName}.${method} (connection not ready)`);
+                return;
+            }
+            checkStartFailed();
+            connection.onRequest(method, handler);
+        },
+        async stop() {
+            let shutdownError;
+            // Mark as stopping to prevent error handlers from logging spurious errors
+            isStopping = true;
+            try {
+                if (connection) {
+                    // Try to send shutdown request and exit notification
+                    await connection.sendRequest('shutdown', {});
+                    await connection.sendNotification('exit', {});
+                }
+            }
+            catch (error) {
+                const err = error;
+                logError(new Error(`LSP server ${serverName} stop failed: ${err.message}`));
+                shutdownError = err;
+                // Continue to cleanup despite shutdown failure
+            }
+            finally {
+                // Always cleanup resources, even if shutdown/exit failed
+                if (connection) {
+                    try {
+                        connection.dispose();
+                    }
+                    catch (error) {
+                        // Log but don't throw - disposal errors are less critical
+                        logForDebugging(`Connection disposal failed for ${serverName}: ${errorMessage(error)}`);
+                    }
+                    connection = undefined;
+                }
+                if (process) {
+                    // Remove event listeners to prevent memory leaks
+                    process.removeAllListeners('error');
+                    process.removeAllListeners('exit');
+                    if (process.stdin) {
+                        process.stdin.removeAllListeners('error');
+                    }
+                    if (process.stderr) {
+                        process.stderr.removeAllListeners('data');
+                    }
+                    try {
+                        process.kill();
+                    }
+                    catch (error) {
+                        // Process might already be dead, which is fine
+                        logForDebugging(`Process kill failed for ${serverName} (may already be dead): ${errorMessage(error)}`);
+                    }
+                    process = undefined;
+                }
+                isInitialized = false;
+                capabilities = undefined;
+                isStopping = false; // Reset for potential restart
+                // Don't reset startFailed - preserve error state for diagnostics
+                // startFailed and startError remain as-is
+                if (shutdownError) {
+                    startFailed = true;
+                    startError = shutdownError;
+                }
+                logForDebugging(`LSP client stopped for ${serverName}`);
+            }
+            // Re-throw shutdown error after cleanup is complete
+            if (shutdownError) {
+                throw shutdownError;
+            }
+        },
+    };
+}

package/src/services/lsp/LSPDiagnosticRegistry.js

@@ -0,0 +1,277 @@
+import { randomUUID } from 'crypto';
+import { LRUCache } from 'lru-cache';
+import { logForDebugging } from '../../utils/debug.js';
+import { toError } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { jsonStringify } from '../../utils/slowOperations.js';
+/**
+ * LSP Diagnostic Registry
+ *
+ * Stores LSP diagnostics received asynchronously from LSP servers via
+ * textDocument/publishDiagnostics notifications. Follows the same pattern
+ * as AsyncHookRegistry for consistent async attachment delivery.
+ *
+ * Pattern:
+ * 1. LSP server sends publishDiagnostics notification
+ * 2. registerPendingLSPDiagnostic() stores diagnostic
+ * 3. checkForLSPDiagnostics() retrieves pending diagnostics
+ * 4. getLSPDiagnosticAttachments() converts to Attachment[]
+ * 5. getAttachments() delivers to conversation automatically
+ *
+ * Similar to AsyncHookRegistry but simpler since diagnostics arrive
+ * synchronously (no need to accumulate output over time).
+ */
+// Volume limiting constants
+const MAX_DIAGNOSTICS_PER_FILE = 10;
+const MAX_TOTAL_DIAGNOSTICS = 30;
+// Max files to track for deduplication - prevents unbounded memory growth
+const MAX_DELIVERED_FILES = 500;
+// Global registry state
+const pendingDiagnostics = new Map();
+// Cross-turn deduplication: tracks diagnostics that have been delivered
+// Maps file URI to a set of diagnostic keys (hash of message+severity+range)
+// Using LRUCache to prevent unbounded growth in long sessions
+const deliveredDiagnostics = new LRUCache({
+    max: MAX_DELIVERED_FILES,
+});
+/**
+ * Register LSP diagnostics received from a server.
+ * These will be delivered as attachments in the next query.
+ *
+ * @param serverName - Name of LSP server that sent diagnostics
+ * @param files - Diagnostic files to deliver
+ */
+export function registerPendingLSPDiagnostic({ serverName, files, }) {
+    // Use UUID for guaranteed uniqueness (handles rapid registrations)
+    const diagnosticId = randomUUID();
+    logForDebugging(`LSP Diagnostics: Registering ${files.length} diagnostic file(s) from ${serverName} (ID: ${diagnosticId})`);
+    pendingDiagnostics.set(diagnosticId, {
+        serverName,
+        files,
+        timestamp: Date.now(),
+        attachmentSent: false,
+    });
+}
+/**
+ * Maps severity string to numeric value for sorting.
+ * Error=1, Warning=2, Info=3, Hint=4
+ */
+function severityToNumber(severity) {
+    switch (severity) {
+        case 'Error':
+            return 1;
+        case 'Warning':
+            return 2;
+        case 'Info':
+            return 3;
+        case 'Hint':
+            return 4;
+        default:
+            return 4;
+    }
+}
+/**
+ * Creates a unique key for a diagnostic based on its content.
+ * Used for both within-batch and cross-turn deduplication.
+ */
+function createDiagnosticKey(diag) {
+    return jsonStringify({
+        message: diag.message,
+        severity: diag.severity,
+        range: diag.range,
+        source: diag.source || null,
+        code: diag.code || null,
+    });
+}
+/**
+ * Deduplicates diagnostics by file URI and diagnostic content.
+ * Also filters out diagnostics that were already delivered in previous turns.
+ * Two diagnostics are considered duplicates if they have the same:
+ * - File URI
+ * - Range (start/end line and character)
+ * - Message
+ * - Severity
+ * - Source and code (if present)
+ */
+function deduplicateDiagnosticFiles(allFiles) {
+    // Group diagnostics by file URI
+    const fileMap = new Map();
+    const dedupedFiles = [];
+    for (const file of allFiles) {
+        if (!fileMap.has(file.uri)) {
+            fileMap.set(file.uri, new Set());
+            dedupedFiles.push({ uri: file.uri, diagnostics: [] });
+        }
+        const seenDiagnostics = fileMap.get(file.uri);
+        const dedupedFile = dedupedFiles.find(f => f.uri === file.uri);
+        // Get previously delivered diagnostics for this file (for cross-turn dedup)
+        const previouslyDelivered = deliveredDiagnostics.get(file.uri) || new Set();
+        for (const diag of file.diagnostics) {
+            try {
+                const key = createDiagnosticKey(diag);
+                // Skip if already seen in this batch OR already delivered in previous turns
+                if (seenDiagnostics.has(key) || previouslyDelivered.has(key)) {
+                    continue;
+                }
+                seenDiagnostics.add(key);
+                dedupedFile.diagnostics.push(diag);
+            }
+            catch (error) {
+                const err = toError(error);
+                const truncatedMessage = diag.message?.substring(0, 100) || '<no message>';
+                logError(new Error(`Failed to deduplicate diagnostic in ${file.uri}: ${err.message}. ` +
+                    `Diagnostic message: ${truncatedMessage}`));
+                // Include the diagnostic anyway to avoid losing information
+                dedupedFile.diagnostics.push(diag);
+            }
+        }
+    }
+    // Filter out files with no diagnostics after deduplication
+    return dedupedFiles.filter(f => f.diagnostics.length > 0);
+}
+/**
+ * Get all pending LSP diagnostics that haven't been delivered yet.
+ * Deduplicates diagnostics to prevent sending the same diagnostic multiple times.
+ * Marks diagnostics as sent to prevent duplicate delivery.
+ *
+ * @returns Array of pending diagnostics ready for delivery (deduplicated)
+ */
+export function checkForLSPDiagnostics() {
+    logForDebugging(`LSP Diagnostics: Checking registry - ${pendingDiagnostics.size} pending`);
+    // Collect all diagnostic files from all pending notifications
+    const allFiles = [];
+    const serverNames = new Set();
+    const diagnosticsToMark = [];
+    for (const diagnostic of pendingDiagnostics.values()) {
+        if (!diagnostic.attachmentSent) {
+            allFiles.push(...diagnostic.files);
+            serverNames.add(diagnostic.serverName);
+            diagnosticsToMark.push(diagnostic);
+        }
+    }
+    if (allFiles.length === 0) {
+        return [];
+    }
+    // Deduplicate diagnostics across all files
+    let dedupedFiles;
+    try {
+        dedupedFiles = deduplicateDiagnosticFiles(allFiles);
+    }
+    catch (error) {
+        const err = toError(error);
+        logError(new Error(`Failed to deduplicate LSP diagnostics: ${err.message}`));
+        // Fall back to undedup'd files to avoid losing diagnostics
+        dedupedFiles = allFiles;
+    }
+    // Only mark as sent AFTER successful deduplication, then delete from map.
+    // Entries are tracked in deliveredDiagnostics LRU for dedup, so we don't
+    // need to keep them in pendingDiagnostics after delivery.
+    for (const diagnostic of diagnosticsToMark) {
+        diagnostic.attachmentSent = true;
+    }
+    for (const [id, diagnostic] of pendingDiagnostics) {
+        if (diagnostic.attachmentSent) {
+            pendingDiagnostics.delete(id);
+        }
+    }
+    const originalCount = allFiles.reduce((sum, f) => sum + f.diagnostics.length, 0);
+    const dedupedCount = dedupedFiles.reduce((sum, f) => sum + f.diagnostics.length, 0);
+    if (originalCount > dedupedCount) {
+        logForDebugging(`LSP Diagnostics: Deduplication removed ${originalCount - dedupedCount} duplicate diagnostic(s)`);
+    }
+    // Apply volume limiting: cap per file and total
+    let totalDiagnostics = 0;
+    let truncatedCount = 0;
+    for (const file of dedupedFiles) {
+        // Sort by severity (Error=1 < Warning=2 < Info=3 < Hint=4) to prioritize errors
+        file.diagnostics.sort((a, b) => severityToNumber(a.severity) - severityToNumber(b.severity));
+        // Cap per file
+        if (file.diagnostics.length > MAX_DIAGNOSTICS_PER_FILE) {
+            truncatedCount += file.diagnostics.length - MAX_DIAGNOSTICS_PER_FILE;
+            file.diagnostics = file.diagnostics.slice(0, MAX_DIAGNOSTICS_PER_FILE);
+        }
+        // Cap total
+        const remainingCapacity = MAX_TOTAL_DIAGNOSTICS - totalDiagnostics;
+        if (file.diagnostics.length > remainingCapacity) {
+            truncatedCount += file.diagnostics.length - remainingCapacity;
+            file.diagnostics = file.diagnostics.slice(0, remainingCapacity);
+        }
+        totalDiagnostics += file.diagnostics.length;
+    }
+    // Filter out files that ended up with no diagnostics after limiting
+    dedupedFiles = dedupedFiles.filter(f => f.diagnostics.length > 0);
+    if (truncatedCount > 0) {
+        logForDebugging(`LSP Diagnostics: Volume limiting removed ${truncatedCount} diagnostic(s) (max ${MAX_DIAGNOSTICS_PER_FILE}/file, ${MAX_TOTAL_DIAGNOSTICS} total)`);
+    }
+    // Track delivered diagnostics for cross-turn deduplication
+    for (const file of dedupedFiles) {
+        if (!deliveredDiagnostics.has(file.uri)) {
+            deliveredDiagnostics.set(file.uri, new Set());
+        }
+        const delivered = deliveredDiagnostics.get(file.uri);
+        for (const diag of file.diagnostics) {
+            try {
+                delivered.add(createDiagnosticKey(diag));
+            }
+            catch (error) {
+                // Log but continue - failure to track shouldn't prevent delivery
+                const err = toError(error);
+                const truncatedMessage = diag.message?.substring(0, 100) || '<no message>';
+                logError(new Error(`Failed to track delivered diagnostic in ${file.uri}: ${err.message}. ` +
+                    `Diagnostic message: ${truncatedMessage}`));
+            }
+        }
+    }
+    const finalCount = dedupedFiles.reduce((sum, f) => sum + f.diagnostics.length, 0);
+    // Return empty if no diagnostics to deliver (all filtered by deduplication)
+    if (finalCount === 0) {
+        logForDebugging(`LSP Diagnostics: No new diagnostics to deliver (all filtered by deduplication)`);
+        return [];
+    }
+    logForDebugging(`LSP Diagnostics: Delivering ${dedupedFiles.length} file(s) with ${finalCount} diagnostic(s) from ${serverNames.size} server(s)`);
+    // Return single result with all deduplicated diagnostics
+    return [
+        {
+            serverName: Array.from(serverNames).join(', '),
+            files: dedupedFiles,
+        },
+    ];
+}
+/**
+ * Clear all pending diagnostics.
+ * Used during cleanup/shutdown or for testing.
+ * Note: Does NOT clear deliveredDiagnostics - that's for cross-turn deduplication
+ * and should only be cleared when files are edited or on session reset.
+ */
+export function clearAllLSPDiagnostics() {
+    logForDebugging(`LSP Diagnostics: Clearing ${pendingDiagnostics.size} pending diagnostic(s)`);
+    pendingDiagnostics.clear();
+}
+/**
+ * Reset all diagnostic state including cross-turn tracking.
+ * Used on session reset or for testing.
+ */
+export function resetAllLSPDiagnosticState() {
+    logForDebugging(`LSP Diagnostics: Resetting all state (${pendingDiagnostics.size} pending, ${deliveredDiagnostics.size} files tracked)`);
+    pendingDiagnostics.clear();
+    deliveredDiagnostics.clear();
+}
+/**
+ * Clear delivered diagnostics for a specific file.
+ * Should be called when a file is edited so that new diagnostics for that file
+ * will be shown even if they match previously delivered ones.
+ *
+ * @param fileUri - URI of the file that was edited
+ */
+export function clearDeliveredDiagnosticsForFile(fileUri) {
+    if (deliveredDiagnostics.has(fileUri)) {
+        logForDebugging(`LSP Diagnostics: Clearing delivered diagnostics for ${fileUri}`);
+        deliveredDiagnostics.delete(fileUri);
+    }
+}
+/**
+ * Get count of pending diagnostics (for monitoring)
+ */
+export function getPendingLSPDiagnosticCount() {
+    return pendingDiagnostics.size;
+}