✨ feat: add LSP server auto-restart functionality

- Add restartInterval option to LSPServerConfig for automatic server restarts
- Implement timer-based restart mechanism to prevent long-running server degradation
- Add comprehensive test coverage for restart functionality
- Update documentation with configuration examples and guidelines
- Particularly beneficial for Python Language Server (pylsp) stability
- Version bump to 0.4.2

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: ktnyt

CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.2] - 2025-06-29
+
+### Added
+
+- **LSP Server Auto-Restart**: Added `restartInterval` option to server configuration for automatic LSP server restarts to prevent long-running server degradation
+- Configurable restart intervals in minutes with minimum 0.1 minute (6 seconds) for testing
+- Comprehensive test coverage for restart functionality including timer setup, configuration validation, and cleanup
+
+### Enhanced
+
+- Improved LSP server stability for long-running sessions, particularly beneficial for Python Language Server (pylsp)
+- Updated documentation with configuration examples and restart interval guidelines
+- **Setup Wizard Improvements**: Enhanced file extension detection with comprehensive .gitignore support
+- Improved project structure scanning to exclude common build artifacts, dependencies, and temporary files
+- Better accuracy in detecting project's primary programming languages for LSP server configuration
+
 ## [0.4.1] - 2025-06-28
 
 ### Added

CLAUDE.md

@@ -109,6 +109,26 @@ Each server config requires:
 - `extensions`: File extensions to handle (array)
 - `command`: Command array to spawn LSP server
 - `rootDir`: Working directory for LSP server (optional)
+- `restartInterval`: Auto-restart interval in minutes (optional, helps with long-running server stability, minimum 1 minute)
+
+### Example Configuration
+
+```json
+{
+  "servers": [
+    {
+      "extensions": ["py"],
+      "command": ["pylsp"],
+      "restartInterval": 5
+    },
+    {
+      "extensions": ["ts", "tsx", "js", "jsx"],
+      "command": ["typescript-language-server", "--stdio"],
+      "restartInterval": 10
+    }
+  ]
+}
+```
 
 ## Code Quality & Testing
 

README.md

@@ -478,6 +478,40 @@ Result: 12 files will be updated with the new name
 
 ## 🔍 Troubleshooting
 
+### Known Issues
+
+<details>
+<summary>🐍 Python LSP Server (pylsp) Performance Degradation</summary>
+
+**Problem**: The Python Language Server (pylsp) may become slow or unresponsive after extended use (several hours), affecting symbol resolution and code navigation.
+
+**Symptoms**:
+- Slow or missing "go to definition" results for Python files
+- Delayed or incomplete symbol references
+- General responsiveness issues with Python code analysis
+
+**Solution**: Use the auto-restart feature to periodically restart the pylsp server:
+
+Add `restartInterval` to your Python server configuration:
+
+```json
+{
+  "servers": [
+    {
+      "extensions": ["py", "pyi"],
+      "command": ["pylsp"],
+      "restartInterval": 5
+    }
+  ]
+}
+```
+
+This will automatically restart the Python LSP server every 5 minutes, maintaining optimal performance for long coding sessions.
+
+**Note**: The setup wizard automatically configures this for Python servers when detected.
+
+</details>
+
 ### Common Issues
 
 <details>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclsp",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "MCP server for accessing LSP functionality",
   "main": "dist/index.js",
   "bin": {

src/language-servers.ts

@@ -7,6 +7,7 @@ export interface LanguageServerConfig {
   rootDir?: string;
   description?: string;
   installRequired?: boolean;
+  restartInterval?: number; // Default restart interval in minutes
 }
 
 export const LANGUAGE_SERVERS: LanguageServerConfig[] = [
@@ -27,6 +28,7 @@ export const LANGUAGE_SERVERS: LanguageServerConfig[] = [
     installInstructions: 'pip install python-lsp-server',
     description: 'Python Language Server Protocol implementation',
     installRequired: false,
+    restartInterval: 5, // Auto-restart every 5 minutes to prevent performance degradation
   },
   {
     name: 'go',
@@ -153,10 +155,24 @@ export function generateConfig(selectedLanguages: string[]): object {
   );
 
   return {
-    servers: selectedServers.map((server) => ({
-      extensions: server.extensions,
-      command: server.command,
-      rootDir: server.rootDir || '.',
-    })),
+    servers: selectedServers.map((server) => {
+      const config: {
+        extensions: string[];
+        command: string[];
+        rootDir: string;
+        restartInterval?: number;
+      } = {
+        extensions: server.extensions,
+        command: server.command,
+        rootDir: server.rootDir || '.',
+      };
+
+      // Add restartInterval if specified for the server
+      if (server.restartInterval) {
+        config.restartInterval = server.restartInterval;
+      }
+
+      return config;
+    }),
   };
 }

src/lsp-client.test.ts

@@ -435,4 +435,94 @@ describe('LSPClient', () => {
       getDocumentSymbolsSpy.mockRestore();
     });
   });
+
+  describe('Server restart functionality', () => {
+    it('should setup restart timer when restartInterval is configured', () => {
+      const client = new LSPClient(TEST_CONFIG_PATH);
+
+      // Mock setTimeout to verify timer is set
+      const setTimeoutSpy = spyOn(global, 'setTimeout').mockImplementation((() => 123) as any);
+
+      const mockServerState = {
+        process: { kill: jest.fn() },
+        initialized: true,
+        initializationPromise: Promise.resolve(),
+        openFiles: new Set(),
+        startTime: Date.now(),
+        config: {
+          extensions: ['ts'],
+          command: ['echo', 'mock'],
+          restartInterval: 0.1, // 0.1 minutes
+        },
+        restartTimer: undefined,
+      };
+
+      try {
+        // Call setupRestartTimer directly
+        (client as any).setupRestartTimer(mockServerState);
+
+        // Verify setTimeout was called with correct interval (0.1 minutes = 6000ms)
+        expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 6000);
+      } finally {
+        setTimeoutSpy.mockRestore();
+        client.dispose();
+      }
+    });
+
+    it('should not setup restart timer when restartInterval is not configured', () => {
+      const client = new LSPClient(TEST_CONFIG_PATH);
+
+      // Mock setTimeout to verify timer is NOT set
+      const setTimeoutSpy = spyOn(global, 'setTimeout').mockImplementation((() => 123) as any);
+
+      const mockServerState = {
+        process: { kill: jest.fn() },
+        initialized: true,
+        initializationPromise: Promise.resolve(),
+        openFiles: new Set(),
+        startTime: Date.now(),
+        config: {
+          extensions: ['ts'],
+          command: ['echo', 'mock'],
+          // No restartInterval
+        },
+        restartTimer: undefined,
+      };
+
+      try {
+        // Call setupRestartTimer directly
+        (client as any).setupRestartTimer(mockServerState);
+
+        // Verify setTimeout was NOT called
+        expect(setTimeoutSpy).not.toHaveBeenCalled();
+      } finally {
+        setTimeoutSpy.mockRestore();
+        client.dispose();
+      }
+    });
+
+    it('should clear restart timer when disposing client', async () => {
+      const client = new LSPClient(TEST_CONFIG_PATH);
+
+      const mockTimer = setTimeout(() => {}, 1000);
+      const mockServerState = {
+        process: { kill: jest.fn() },
+        restartTimer: mockTimer,
+      };
+
+      // Mock servers map to include our test server state
+      const serversMap = new Map();
+      serversMap.set('test-key', mockServerState);
+      (client as any).servers = serversMap;
+
+      const clearTimeoutSpy = spyOn(global, 'clearTimeout');
+
+      client.dispose();
+
+      expect(clearTimeoutSpy).toHaveBeenCalledWith(mockTimer);
+      expect(mockServerState.process.kill).toHaveBeenCalled();
+
+      clearTimeoutSpy.mockRestore();
+    });
+  });
 });

src/lsp-client.ts

@@ -30,6 +30,9 @@ interface ServerState {
   initialized: boolean;
   initializationPromise: Promise<void>;
   openFiles: Set<string>;
+  startTime: number;
+  config: LSPServerConfig;
+  restartTimer?: NodeJS.Timeout;
 }
 
 export class LSPClient {
@@ -128,6 +131,9 @@ export class LSPClient {
       initialized: false,
       initializationPromise,
       openFiles: new Set(),
+      startTime: Date.now(),
+      config: serverConfig,
+      restartTimer: undefined,
     };
 
     let buffer = '';
@@ -237,6 +243,10 @@ export class LSPClient {
 
     serverState.initialized = true;
     initializationResolve?.();
+
+    // Set up auto-restart timer if configured
+    this.setupRestartTimer(serverState);
+
     return serverState;
   }
 
@@ -290,6 +300,54 @@ export class LSPClient {
     this.sendMessage(process, message);
   }
 
+  private setupRestartTimer(serverState: ServerState): void {
+    if (serverState.config.restartInterval && serverState.config.restartInterval > 0) {
+      // Minimum interval is 0.1 minutes (6 seconds) for testing, practical minimum is 1 minute
+      const minInterval = 0.1;
+      const actualInterval = Math.max(serverState.config.restartInterval, minInterval);
+      const intervalMs = actualInterval * 60 * 1000; // Convert minutes to milliseconds
+
+      process.stderr.write(
+        `[DEBUG setupRestartTimer] Setting up restart timer for ${actualInterval} minutes\n`
+      );
+
+      serverState.restartTimer = setTimeout(() => {
+        this.restartServer(serverState);
+      }, intervalMs);
+    }
+  }
+
+  private async restartServer(serverState: ServerState): Promise<void> {
+    const key = JSON.stringify(serverState.config);
+    process.stderr.write(
+      `[DEBUG restartServer] Restarting LSP server for ${serverState.config.command.join(' ')}\n`
+    );
+
+    // Clear existing timer
+    if (serverState.restartTimer) {
+      clearTimeout(serverState.restartTimer);
+      serverState.restartTimer = undefined;
+    }
+
+    // Terminate old server
+    serverState.process.kill();
+
+    // Remove from servers map
+    this.servers.delete(key);
+
+    try {
+      // Start new server
+      const newServerState = await this.startServer(serverState.config);
+      this.servers.set(key, newServerState);
+
+      process.stderr.write(
+        `[DEBUG restartServer] Successfully restarted LSP server for ${serverState.config.command.join(' ')}\n`
+      );
+    } catch (error) {
+      process.stderr.write(`[DEBUG restartServer] Failed to restart LSP server: ${error}\n`);
+    }
+  }
+
   private async ensureFileOpen(serverState: ServerState, filePath: string): Promise<void> {
     if (serverState.openFiles.has(filePath)) {
       process.stderr.write(`[DEBUG ensureFileOpen] File already open: ${filePath}\n`);
@@ -983,6 +1041,10 @@ export class LSPClient {
 
   dispose(): void {
     for (const serverState of this.servers.values()) {
+      // Clear restart timer if exists
+      if (serverState.restartTimer) {
+        clearTimeout(serverState.restartTimer);
+      }
       serverState.process.kill();
     }
     this.servers.clear();

src/setup.test.ts

@@ -8,6 +8,7 @@ interface GeneratedConfig {
     extensions: string[];
     command: string[];
     rootDir: string;
+    restartInterval?: number;
   }>;
 }
 
@@ -120,6 +121,28 @@ describe('generateConfig', () => {
     expect(serverNames).toContain('go');
   });
 
+  test('should include restartInterval for Python server', () => {
+    const config = generateConfig(['python']);
+    expect(config).toHaveProperty('servers');
+    expect(Array.isArray((config as GeneratedConfig).servers)).toBe(true);
+    expect((config as GeneratedConfig).servers).toHaveLength(1);
+
+    const pythonServer = (config as GeneratedConfig).servers[0];
+    expect(pythonServer?.extensions).toContain('py');
+    expect(pythonServer?.restartInterval).toBe(5);
+  });
+
+  test('should not include restartInterval for servers without it configured', () => {
+    const config = generateConfig(['typescript']);
+    expect(config).toHaveProperty('servers');
+    expect(Array.isArray((config as GeneratedConfig).servers)).toBe(true);
+    expect((config as GeneratedConfig).servers).toHaveLength(1);
+
+    const typescriptServer = (config as GeneratedConfig).servers[0];
+    expect(typescriptServer?.extensions).toContain('ts');
+    expect(typescriptServer?.restartInterval).toBeUndefined();
+  });
+
   test('should handle invalid language names gracefully', () => {
     const config = generateConfig(['nonexistent', 'typescript']);
     expect(config).toHaveProperty('servers');