driftdetect-vscode 0.8.2

package/src/client/connection-manager.ts

@@ -0,0 +1,263 @@
+/**
+ * ConnectionManager - LSP connection lifecycle management
+ * 
+ * Single responsibility: Manage LSP client connection with auto-recovery.
+ */
+
+import * as vscode from 'vscode';
+
+import { CONNECTION_CONFIG } from './connection-config.js';
+import { createLanguageClient } from './language-client-factory.js';
+
+import type { EventBus } from '../infrastructure/event-bus.js';
+import type { Logger } from '../infrastructure/index.js';
+import type { ConnectionState, ServerConfig } from '../types/index.js';
+import type { LanguageClient, StateChangeEvent } from 'vscode-languageclient/node';
+
+
+/**
+ * Connection manager for LSP client
+ */
+export class ConnectionManager implements vscode.Disposable {
+  private client: LanguageClient | null = null;
+  private state: ConnectionState = 'disconnected';
+  private restartCount = 0;
+  private healthCheckTimer: NodeJS.Timeout | null = null;
+  private readonly disposables: vscode.Disposable[] = [];
+
+  private readonly stateEmitter = new vscode.EventEmitter<ConnectionState>();
+  readonly onStateChange = this.stateEmitter.event;
+
+  constructor(
+    private readonly context: vscode.ExtensionContext,
+    private readonly logger: Logger,
+    private readonly eventBus: EventBus,
+    private config: ServerConfig
+  ) {}
+
+  /**
+   * Get current connection state
+   */
+  getState(): ConnectionState {
+    return this.state;
+  }
+
+  /**
+   * Get the language client (if connected)
+   */
+  getClient(): LanguageClient | null {
+    return this.state === 'connected' ? this.client : null;
+  }
+
+  /**
+   * Connect to the LSP server
+   */
+  async connect(): Promise<void> {
+    if (this.state === 'connected' || this.state === 'connecting') {
+      this.logger.debug('Already connected or connecting');
+      return;
+    }
+
+    this.setState('connecting');
+
+    try {
+      this.client = createLanguageClient(this.context, this.logger, this.config);
+      
+      // Set up client event handlers
+      this.setupClientHandlers();
+
+      // Start the client
+      await this.client.start();
+
+      // Wait for ready state
+      await this.waitForReady();
+
+      this.setState('connected');
+      this.restartCount = 0;
+      this.startHealthCheck();
+
+      this.logger.info('Connected to Drift LSP server');
+      
+    } catch (error) {
+      await this.handleConnectionError(error);
+    }
+  }
+
+  /**
+   * Disconnect from the LSP server
+   */
+  async disconnect(): Promise<void> {
+    this.stopHealthCheck();
+
+    if (this.client) {
+      try {
+        await Promise.race([
+          this.client.stop(),
+          this.timeout(CONNECTION_CONFIG.shutdownTimeout),
+        ]);
+      } catch (error) {
+        this.logger.warn('Error during disconnect:', error);
+      }
+      this.client = null;
+    }
+
+    this.setState('disconnected');
+    this.logger.info('Disconnected from Drift LSP server');
+  }
+
+  /**
+   * Reconnect to the LSP server
+   */
+  async reconnect(): Promise<void> {
+    await this.disconnect();
+    await this.connect();
+  }
+
+  /**
+   * Update server configuration
+   */
+  updateConfig(config: ServerConfig): void {
+    this.config = config;
+  }
+
+  /**
+   * Dispose resources
+   */
+  dispose(): void {
+    this.stopHealthCheck();
+    this.stateEmitter.dispose();
+    
+    if (this.client) {
+      this.client.stop().catch(() => {});
+      this.client = null;
+    }
+
+    for (const d of this.disposables) {
+      d.dispose();
+    }
+  }
+
+  private setState(state: ConnectionState): void {
+    const previousState = this.state;
+    this.state = state;
+    this.stateEmitter.fire(state);
+    this.eventBus.emit('connection:changed', { status: state, previousStatus: previousState });
+  }
+
+  private setupClientHandlers(): void {
+    if (!this.client) {return;}
+
+    // Handle client errors
+    this.client.onDidChangeState((event: StateChangeEvent) => {
+      this.logger.debug(`Client state changed: ${event.oldState} -> ${event.newState}`);
+    });
+  }
+
+  private async waitForReady(): Promise<void> {
+    if (!this.client) {
+      throw new Error('Client not initialized');
+    }
+
+    const timeout = CONNECTION_CONFIG.initializeTimeout;
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < timeout) {
+      if (this.client.isRunning()) {
+        return;
+      }
+      await this.delay(100);
+    }
+
+    throw new Error(`Server initialization timed out after ${timeout}ms`);
+  }
+
+  private async handleConnectionError(error: unknown): Promise<void> {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    this.logger.error('Connection error:', errorMessage);
+
+    this.setState('error');
+    this.eventBus.emit('connection:error', {
+      error: error instanceof Error ? error : new Error(errorMessage),
+      recoverable: this.restartCount < CONNECTION_CONFIG.maxRestarts,
+    });
+
+    if (this.restartCount >= CONNECTION_CONFIG.maxRestarts) {
+      this.setState('failed');
+      this.logger.error(`Max restart attempts (${CONNECTION_CONFIG.maxRestarts}) reached`);
+      return;
+    }
+
+    const delay = this.calculateBackoff();
+    this.restartCount++;
+
+    this.logger.info(
+      `Reconnecting in ${delay}ms (attempt ${this.restartCount}/${CONNECTION_CONFIG.maxRestarts})`
+    );
+
+    this.setState('reconnecting');
+    await this.delay(delay);
+    await this.connect();
+  }
+
+  private calculateBackoff(): number {
+    const delay = CONNECTION_CONFIG.restartDelay * 
+      Math.pow(CONNECTION_CONFIG.backoffMultiplier, this.restartCount);
+    return Math.min(delay, CONNECTION_CONFIG.maxBackoffDelay);
+  }
+
+  private startHealthCheck(): void {
+    this.stopHealthCheck();
+
+    this.healthCheckTimer = setInterval(async () => {
+      if (!await this.isHealthy()) {
+        this.logger.warn('Health check failed, reconnecting...');
+        await this.reconnect();
+      }
+    }, CONNECTION_CONFIG.healthCheckInterval);
+  }
+
+  private stopHealthCheck(): void {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+  }
+
+  private async isHealthy(): Promise<boolean> {
+    if (!this.client?.isRunning()) {
+      return false;
+    }
+
+    try {
+      await Promise.race([
+        this.client.sendRequest('drift/health'),
+        this.timeout(5000),
+      ]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private timeout(ms: number): Promise<never> {
+    return new Promise((_, reject) => {
+      setTimeout(() => { reject(new Error('Timeout')); }, ms);
+    });
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+/**
+ * Factory function for creating connection manager
+ */
+export function createConnectionManager(
+  context: vscode.ExtensionContext,
+  logger: Logger,
+  eventBus: EventBus,
+  config: ServerConfig
+): ConnectionManager {
+  return new ConnectionManager(context, logger, eventBus, config);
+}

package/src/client/index.ts

@@ -0,0 +1,8 @@
+/**
+ * LSP Client module exports
+ */
+
+export { ConnectionManager, createConnectionManager } from './connection-manager.js';
+export { LanguageClientFactory, createLanguageClient } from './language-client-factory.js';
+export { RequestMiddleware, createRequestMiddleware } from './request-middleware.js';
+export { CONNECTION_CONFIG } from './connection-config.js';

package/src/client/language-client-factory.ts

@@ -0,0 +1,111 @@
+/**
+ * LanguageClientFactory - Creates configured LSP clients
+ * 
+ * Single responsibility: Create and configure LanguageClient instances.
+ */
+
+import * as path from 'node:path';
+
+import * as vscode from 'vscode';
+import {
+  LanguageClient,
+  LanguageClientOptions,
+  ServerOptions,
+  TransportKind,
+} from 'vscode-languageclient/node';
+
+import { DOCUMENT_SELECTORS } from './connection-config.js';
+
+import type { Logger } from '../infrastructure/index.js';
+import type { ServerConfig } from '../types/index.js';
+
+/**
+ * Factory for creating language clients
+ */
+export class LanguageClientFactory {
+  constructor(
+    private readonly context: vscode.ExtensionContext,
+    private readonly logger: Logger
+  ) {}
+
+  /**
+   * Create a new language client
+   */
+  create(config: ServerConfig): LanguageClient {
+    const serverOptions = this.createServerOptions(config);
+    const clientOptions = this.createClientOptions(config);
+
+    const client = new LanguageClient(
+      'drift',
+      'Drift Language Server',
+      serverOptions,
+      clientOptions
+    );
+
+    return client;
+  }
+
+  private createServerOptions(config: ServerConfig): ServerOptions {
+    // Use custom path if provided, otherwise use bundled server
+    const serverModule = config.path || this.getBundledServerPath();
+
+    this.logger.debug(`Server module: ${serverModule}`);
+
+    return {
+      run: {
+        module: serverModule,
+        transport: TransportKind.ipc,
+        args: config.args,
+      },
+      debug: {
+        module: serverModule,
+        transport: TransportKind.ipc,
+        args: [...config.args, '--debug'],
+        options: {
+          execArgv: ['--nolazy', '--inspect=6009'],
+        },
+      },
+    };
+  }
+
+  private createClientOptions(config: ServerConfig): LanguageClientOptions {
+    return {
+      documentSelector: DOCUMENT_SELECTORS,
+      synchronize: {
+        // Watch .drift directory for config changes
+        fileEvents: vscode.workspace.createFileSystemWatcher('**/.drift/**'),
+      },
+      outputChannel: vscode.window.createOutputChannel('Drift LSP'),
+      traceOutputChannel: vscode.window.createOutputChannel('Drift LSP Trace'),
+      initializationOptions: {
+        trace: config.trace,
+      },
+    };
+  }
+
+  private getBundledServerPath(): string {
+    // Look for the LSP server in the extension's dependencies
+    const serverPath = path.join(
+      this.context.extensionPath,
+      'node_modules',
+      'driftdetect-lsp',
+      'dist',
+      'bin',
+      'server.js'
+    );
+
+    return serverPath;
+  }
+}
+
+/**
+ * Factory function for creating language client factory
+ */
+export function createLanguageClient(
+  context: vscode.ExtensionContext,
+  logger: Logger,
+  config: ServerConfig
+): LanguageClient {
+  const factory = new LanguageClientFactory(context, logger);
+  return factory.create(config);
+}

package/src/client/request-middleware.ts

@@ -0,0 +1,117 @@
+/**
+ * RequestMiddleware - Request/response interceptors
+ * 
+ * Single responsibility: Add retry, timeout, and logging to LSP requests.
+ */
+
+import { CONNECTION_CONFIG } from './connection-config.js';
+
+import type { Logger } from '../infrastructure/index.js';
+import type { LanguageClient } from 'vscode-languageclient/node';
+
+/**
+ * Request options
+ */
+export interface RequestOptions {
+  timeout?: number;
+  retries?: number;
+  retryDelay?: number;
+}
+
+/**
+ * Default request options
+ */
+const DEFAULT_OPTIONS: Required<RequestOptions> = {
+  timeout: CONNECTION_CONFIG.requestTimeout,
+  retries: 2,
+  retryDelay: 500,
+};
+
+/**
+ * Middleware for LSP requests with retry and timeout
+ */
+export class RequestMiddleware {
+  constructor(
+    private readonly client: LanguageClient,
+    private readonly logger: Logger
+  ) {}
+
+  /**
+   * Send a request with retry and timeout
+   */
+  async request<T>(
+    method: string,
+    params?: unknown,
+    options: RequestOptions = {}
+  ): Promise<T> {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt <= opts.retries; attempt++) {
+      try {
+        const result = await this.sendWithTimeout<T>(method, params, opts.timeout);
+        return result;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        
+        if (attempt < opts.retries) {
+          this.logger.warn(
+            `Request ${method} failed (attempt ${attempt + 1}/${opts.retries + 1}): ${lastError.message}`
+          );
+          await this.delay(opts.retryDelay * (attempt + 1));
+        }
+      }
+    }
+
+    this.logger.error(`Request ${method} failed after ${opts.retries + 1} attempts`);
+    throw lastError;
+  }
+
+  /**
+   * Send a notification (fire and forget)
+   */
+  notify(method: string, params?: unknown): void {
+    try {
+      this.client.sendNotification(method, params);
+    } catch (error) {
+      this.logger.error(`Notification ${method} failed:`, error);
+    }
+  }
+
+  private async sendWithTimeout<T>(
+    method: string,
+    params: unknown,
+    timeout: number
+  ): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Request ${method} timed out after ${timeout}ms`));
+      }, timeout);
+
+      this.client
+        .sendRequest<T>(method, params)
+        .then((result) => {
+          clearTimeout(timer);
+          resolve(result);
+        })
+        .catch((error) => {
+          clearTimeout(timer);
+          reject(error);
+        });
+    });
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+/**
+ * Factory function for creating request middleware
+ */
+export function createRequestMiddleware(
+  client: LanguageClient,
+  logger: Logger
+): RequestMiddleware {
+  return new RequestMiddleware(client, logger);
+}