driftdetect-vscode 0.8.2

package/src/config/config-manager.ts

@@ -0,0 +1,213 @@
+/**
+ * ConfigManager - Configuration management with change detection
+ * 
+ * Single responsibility: Load, validate, and watch configuration.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import * as vscode from 'vscode';
+
+import { DEFAULT_CONFIG } from './defaults.js';
+import { validateConfig } from './validator.js';
+
+import type { Logger } from '../infrastructure/index.js';
+import type { DriftConfig, ConfigChangeEvent, TeamConfig } from '../types/index.js';
+
+/**
+ * Configuration manager with reactive updates
+ */
+export class ConfigManager implements vscode.Disposable {
+  private config: DriftConfig;
+  private readonly disposables: vscode.Disposable[] = [];
+  private readonly changeEmitter = new vscode.EventEmitter<ConfigChangeEvent>();
+  
+  readonly onConfigChange = this.changeEmitter.event;
+
+  constructor(private readonly logger: Logger) {
+    this.config = this.loadConfig();
+    this.watchConfig();
+  }
+
+  /**
+   * Get a configuration section
+   */
+  get<K extends keyof DriftConfig>(section: K): DriftConfig[K] {
+    return this.config[section];
+  }
+
+  /**
+   * Get the full configuration
+   */
+  getAll(): Readonly<DriftConfig> {
+    return this.config;
+  }
+
+  /**
+   * Update a configuration section
+   */
+  async update<K extends keyof DriftConfig>(
+    section: K,
+    value: Partial<DriftConfig[K]>,
+    target: vscode.ConfigurationTarget = vscode.ConfigurationTarget.Workspace
+  ): Promise<void> {
+    const vsConfig = vscode.workspace.getConfiguration('drift');
+    const current = vsConfig.get<DriftConfig[K]>(section);
+    const merged = { ...current, ...value };
+
+    // Validate before updating
+    const validation = validateConfig({ [section]: merged });
+    if (!validation.valid) {
+      this.logger.error('Invalid configuration:', validation.errors);
+      throw new Error(`Invalid configuration: ${validation.errors.join(', ')}`);
+    }
+
+    await vsConfig.update(section, merged, target);
+  }
+
+  /**
+   * Reset configuration to defaults
+   */
+  async reset(target: vscode.ConfigurationTarget = vscode.ConfigurationTarget.Workspace): Promise<void> {
+    const vsConfig = vscode.workspace.getConfiguration('drift');
+    
+    for (const [section, value] of Object.entries(DEFAULT_CONFIG)) {
+      if (section !== 'team') {
+        await vsConfig.update(section, value, target);
+      }
+    }
+  }
+
+  /**
+   * Reload configuration from VS Code settings
+   */
+  reload(): void {
+    const oldConfig = this.config;
+    this.config = this.loadConfig();
+    this.emitChanges(oldConfig, this.config);
+  }
+
+  /**
+   * Dispose resources
+   */
+  dispose(): void {
+    this.changeEmitter.dispose();
+    for (const d of this.disposables) {
+      d.dispose();
+    }
+  }
+
+  private loadConfig(): DriftConfig {
+    const vsConfig = vscode.workspace.getConfiguration('drift');
+
+    return {
+      server: {
+        path: vsConfig.get('server.path', DEFAULT_CONFIG.server.path),
+        args: vsConfig.get('server.args', DEFAULT_CONFIG.server.args),
+        trace: vsConfig.get('server.trace', DEFAULT_CONFIG.server.trace),
+      },
+      scan: {
+        onSave: vsConfig.get('scan.onSave', DEFAULT_CONFIG.scan.onSave),
+        onOpen: vsConfig.get('scan.onOpen', DEFAULT_CONFIG.scan.onOpen),
+        debounceMs: vsConfig.get('scan.debounceMs', DEFAULT_CONFIG.scan.debounceMs),
+        excludePatterns: vsConfig.get('scan.excludePatterns', DEFAULT_CONFIG.scan.excludePatterns),
+      },
+      display: {
+        showStatusBar: vsConfig.get('display.showStatusBar', DEFAULT_CONFIG.display.showStatusBar),
+        showInlineHints: vsConfig.get('display.showInlineHints', DEFAULT_CONFIG.display.showInlineHints),
+        showGutterIcons: vsConfig.get('display.showGutterIcons', DEFAULT_CONFIG.display.showGutterIcons),
+        severityFilter: vsConfig.get('display.severityFilter', DEFAULT_CONFIG.display.severityFilter),
+      },
+      ai: {
+        enabled: vsConfig.get('ai.enabled', DEFAULT_CONFIG.ai.enabled),
+        provider: vsConfig.get('ai.provider', DEFAULT_CONFIG.ai.provider),
+        model: vsConfig.get('ai.model', DEFAULT_CONFIG.ai.model),
+      },
+      team: this.loadTeamConfig(),
+    };
+  }
+
+  private loadTeamConfig(): TeamConfig {
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    if (!workspaceFolder) {
+      return DEFAULT_CONFIG.team;
+    }
+
+    const configPath = path.join(workspaceFolder.uri.fsPath, '.drift', 'config.json');
+
+    try {
+      if (fs.existsSync(configPath)) {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        return {
+          enforceApproved: parsed.enforceApproved ?? DEFAULT_CONFIG.team.enforceApproved,
+          requiredCategories: parsed.requiredCategories ?? DEFAULT_CONFIG.team.requiredCategories,
+          customRules: parsed.customRules ?? DEFAULT_CONFIG.team.customRules,
+        };
+      }
+    } catch (error) {
+      this.logger.warn('Failed to load team config:', error);
+    }
+
+    return DEFAULT_CONFIG.team;
+  }
+
+  private watchConfig(): void {
+    // Watch VS Code settings
+    this.disposables.push(
+      vscode.workspace.onDidChangeConfiguration((event) => {
+        if (event.affectsConfiguration('drift')) {
+          this.reload();
+        }
+      })
+    );
+
+    // Watch .drift/config.json
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    if (workspaceFolder) {
+      const pattern = new vscode.RelativePattern(workspaceFolder, '.drift/config.json');
+      const watcher = vscode.workspace.createFileSystemWatcher(pattern);
+
+      watcher.onDidChange(() => { this.reloadTeamConfig(); });
+      watcher.onDidCreate(() => { this.reloadTeamConfig(); });
+      watcher.onDidDelete(() => { this.reloadTeamConfig(); });
+
+      this.disposables.push(watcher);
+    }
+  }
+
+  private reloadTeamConfig(): void {
+    const oldTeam = this.config.team;
+    this.config = { ...this.config, team: this.loadTeamConfig() };
+    
+    if (JSON.stringify(oldTeam) !== JSON.stringify(this.config.team)) {
+      this.changeEmitter.fire({
+        section: 'team',
+        oldValue: oldTeam,
+        newValue: this.config.team,
+      });
+    }
+  }
+
+  private emitChanges(oldConfig: DriftConfig, newConfig: DriftConfig): void {
+    const sections: (keyof DriftConfig)[] = ['server', 'scan', 'display', 'ai', 'team'];
+
+    for (const section of sections) {
+      if (JSON.stringify(oldConfig[section]) !== JSON.stringify(newConfig[section])) {
+        this.changeEmitter.fire({
+          section,
+          oldValue: oldConfig[section],
+          newValue: newConfig[section],
+        });
+      }
+    }
+  }
+}
+
+/**
+ * Factory function for creating config manager
+ */
+export function createConfigManager(logger: Logger): ConfigManager {
+  return new ConfigManager(logger);
+}

package/src/config/defaults.ts

@@ -0,0 +1,45 @@
+/**
+ * Default configuration values
+ * 
+ * Single responsibility: Provide default config values.
+ */
+
+import type { DriftConfig } from '../types/index.js';
+
+/**
+ * Default configuration
+ */
+export const DEFAULT_CONFIG: DriftConfig = {
+  server: {
+    path: '',
+    args: [],
+    trace: 'off',
+  },
+  scan: {
+    onSave: true,
+    onOpen: true,
+    debounceMs: 200,
+    excludePatterns: [
+      '**/node_modules/**',
+      '**/dist/**',
+      '**/.git/**',
+      '**/coverage/**',
+    ],
+  },
+  display: {
+    showStatusBar: true,
+    showInlineHints: true,
+    showGutterIcons: true,
+    severityFilter: ['error', 'warning'],
+  },
+  ai: {
+    enabled: false,
+    provider: 'none',
+    model: '',
+  },
+  team: {
+    enforceApproved: false,
+    requiredCategories: [],
+    customRules: [],
+  },
+};

package/src/config/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Configuration module exports
+ */
+
+export { ConfigManager, createConfigManager } from './config-manager.js';
+export { DEFAULT_CONFIG } from './defaults.js';
+export { validateConfig } from './validator.js';

package/src/config/validator.ts

@@ -0,0 +1,118 @@
+/**
+ * Configuration validator
+ * 
+ * Single responsibility: Validate configuration values.
+ */
+
+import type { DriftConfig, Severity, AIProvider } from '../types/index.js';
+
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+
+/**
+ * Valid severity values
+ */
+const VALID_SEVERITIES: Severity[] = ['error', 'warning', 'info', 'hint'];
+
+/**
+ * Valid AI providers
+ */
+const VALID_PROVIDERS: AIProvider[] = ['openai', 'anthropic', 'ollama', 'none'];
+
+/**
+ * Valid trace levels
+ */
+const VALID_TRACE_LEVELS = ['off', 'messages', 'verbose'] as const;
+
+/**
+ * Validate configuration
+ */
+export function validateConfig(config: Partial<DriftConfig>): ValidationResult {
+  const errors: string[] = [];
+
+  // Validate server config
+  if (config.server) {
+    if (config.server.trace && !VALID_TRACE_LEVELS.includes(config.server.trace)) {
+      errors.push(`Invalid trace level: ${config.server.trace}`);
+    }
+  }
+
+  // Validate scan config
+  if (config.scan) {
+    if (typeof config.scan.debounceMs === 'number' && config.scan.debounceMs < 0) {
+      errors.push('debounceMs must be non-negative');
+    }
+    if (config.scan.excludePatterns && !Array.isArray(config.scan.excludePatterns)) {
+      errors.push('excludePatterns must be an array');
+    }
+  }
+
+  // Validate display config
+  if (config.display) {
+    if (config.display.severityFilter) {
+      for (const severity of config.display.severityFilter) {
+        if (!VALID_SEVERITIES.includes(severity)) {
+          errors.push(`Invalid severity: ${severity}`);
+        }
+      }
+    }
+  }
+
+  // Validate AI config
+  if (config.ai) {
+    if (config.ai.provider && !VALID_PROVIDERS.includes(config.ai.provider)) {
+      errors.push(`Invalid AI provider: ${config.ai.provider}`);
+    }
+    if (config.ai.enabled && config.ai.provider === 'none') {
+      errors.push('AI enabled but provider is "none"');
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Validate a single config value
+ */
+export function validateConfigValue(
+  section: keyof DriftConfig,
+  key: string,
+  value: unknown
+): ValidationResult {
+  const errors: string[] = [];
+
+  switch (section) {
+    case 'scan':
+      if (key === 'debounceMs' && (typeof value !== 'number' || value < 0)) {
+        errors.push('debounceMs must be a non-negative number');
+      }
+      break;
+    case 'display':
+      if (key === 'severityFilter' && Array.isArray(value)) {
+        for (const v of value) {
+          if (!VALID_SEVERITIES.includes(v as Severity)) {
+            errors.push(`Invalid severity: ${v}`);
+          }
+        }
+      }
+      break;
+    case 'ai':
+      if (key === 'provider' && !VALID_PROVIDERS.includes(value as AIProvider)) {
+        errors.push(`Invalid AI provider: ${value}`);
+      }
+      break;
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}

package/src/extension.ts

@@ -0,0 +1,57 @@
+/**
+ * @drift/vscode - VS Code Extension Entry Point
+ *
+ * This is the main entry point for the Drift VS Code extension.
+ * It delegates all work to the ActivationController for proper
+ * lifecycle management and phased activation.
+ */
+
+import * as vscode from 'vscode';
+
+import { createActivationController, type ActivationController } from './activation/index.js';
+
+/**
+ * Extension version - read from package.json at runtime
+ */
+export function getVersion(): string {
+  const extension = vscode.extensions.getExtension('driftdetect.driftdetect-vscode');
+  return extension?.packageJSON?.version ?? '0.0.0';
+}
+
+// For backwards compatibility
+export const VERSION = '0.4.4';
+
+/**
+ * Activation controller instance
+ */
+let controller: ActivationController | null = null;
+
+/**
+ * Activates the Drift extension
+ * 
+ * This function is called by VS Code when the extension is activated.
+ * Activation is phased for optimal startup performance:
+ * 
+ * 1. Immediate phase (<100ms): Infrastructure, state, config, status bar
+ * 2. Deferred phase: LSP connection, commands, decorations
+ * 3. Lazy phase: Tree views, webviews (on-demand)
+ */
+export async function activate(context: vscode.ExtensionContext): Promise<void> {
+  controller = createActivationController(context);
+  context.subscriptions.push(controller);
+  
+  await controller.activate();
+}
+
+/**
+ * Deactivates the Drift extension
+ * 
+ * This function is called by VS Code when the extension is deactivated.
+ * It ensures proper cleanup of all resources.
+ */
+export async function deactivate(): Promise<void> {
+  if (controller) {
+    await controller.deactivate();
+    controller = null;
+  }
+}

package/src/infrastructure/disposable-manager.ts

@@ -0,0 +1,87 @@
+/**
+ * DisposableManager - Centralized resource cleanup
+ * 
+ * Single responsibility: Track and dispose VS Code disposables.
+ */
+
+import * as vscode from 'vscode';
+
+import type { DisposableManager as IDisposableManager } from '../types/index.js';
+
+/**
+ * Manages disposable resources for proper cleanup
+ */
+export class DisposableManager implements IDisposableManager, vscode.Disposable {
+  private readonly disposables: vscode.Disposable[] = [];
+  private disposed = false;
+
+  /**
+   * Add a disposable to be managed
+   */
+  add(disposable: vscode.Disposable): void {
+    if (this.disposed) {
+      // If already disposed, dispose the new item immediately
+      disposable.dispose();
+      return;
+    }
+    this.disposables.push(disposable);
+  }
+
+  /**
+   * Add multiple disposables
+   */
+  addAll(...disposables: vscode.Disposable[]): void {
+    for (const d of disposables) {
+      this.add(d);
+    }
+  }
+
+  /**
+   * Create a disposable from a cleanup function
+   */
+  addCallback(cleanup: () => void): void {
+    this.add({ dispose: cleanup });
+  }
+
+  /**
+   * Dispose all managed resources
+   */
+  dispose(): void {
+    if (this.disposed) {
+      return;
+    }
+    
+    this.disposed = true;
+    
+    // Dispose in reverse order (LIFO)
+    while (this.disposables.length > 0) {
+      const disposable = this.disposables.pop();
+      try {
+        disposable?.dispose();
+      } catch (error) {
+        console.error('[Drift] Error disposing resource:', error);
+      }
+    }
+  }
+
+  /**
+   * Check if already disposed
+   */
+  isDisposed(): boolean {
+    return this.disposed;
+  }
+
+  /**
+   * Get count of managed disposables
+   */
+  get count(): number {
+    return this.disposables.length;
+  }
+}
+
+/**
+ * Factory function for creating disposable managers
+ */
+export function createDisposableManager(): DisposableManager {
+  return new DisposableManager();
+}

package/src/infrastructure/event-bus.ts

@@ -0,0 +1,121 @@
+/**
+ * EventBus - Decoupled event communication
+ * 
+ * Single responsibility: Enable pub/sub communication between components.
+ */
+
+import * as vscode from 'vscode';
+
+/**
+ * Event types for the extension
+ */
+export type ExtensionEventType =
+  | 'connection:changed'
+  | 'connection:error'
+  | 'patterns:updated'
+  | 'violations:updated'
+  | 'scan:started'
+  | 'scan:completed'
+  | 'config:changed'
+  | 'workspace:changed';
+
+/**
+ * Event payload types
+ */
+export interface ExtensionEvents {
+  'connection:changed': { status: string; previousStatus: string };
+  'connection:error': { error: Error; recoverable: boolean };
+  'patterns:updated': { total: number; categories: string[] };
+  'violations:updated': { total: number; file?: string };
+  'scan:started': { files: number };
+  'scan:completed': { duration: number; patterns: number; violations: number };
+  'config:changed': { section: string; oldValue: unknown; newValue: unknown };
+  'workspace:changed': { folders: string[] };
+}
+
+/**
+ * Event listener type
+ */
+type EventListener<T> = (data: T) => void;
+
+/**
+ * Type-safe event bus for extension-wide communication
+ */
+export class EventBus implements vscode.Disposable {
+  private readonly emitters = new Map<string, vscode.EventEmitter<unknown>>();
+  private readonly disposables: vscode.Disposable[] = [];
+
+  /**
+   * Subscribe to an event
+   */
+  on<K extends ExtensionEventType>(
+    event: K,
+    listener: EventListener<ExtensionEvents[K]>
+  ): vscode.Disposable {
+    const emitter = this.getOrCreateEmitter(event);
+    return emitter.event(listener as EventListener<unknown>);
+  }
+
+  /**
+   * Subscribe to an event once
+   */
+  once<K extends ExtensionEventType>(
+    event: K,
+    listener: EventListener<ExtensionEvents[K]>
+  ): vscode.Disposable {
+    const disposable = this.on(event, (data) => {
+      disposable.dispose();
+      listener(data);
+    });
+    return disposable;
+  }
+
+  /**
+   * Emit an event
+   */
+  emit<K extends ExtensionEventType>(event: K, data: ExtensionEvents[K]): void {
+    const emitter = this.emitters.get(event);
+    if (emitter) {
+      emitter.fire(data);
+    }
+  }
+
+  /**
+   * Check if event has listeners
+   */
+  hasListeners(event: ExtensionEventType): boolean {
+    return this.emitters.has(event);
+  }
+
+  /**
+   * Dispose all emitters
+   */
+  dispose(): void {
+    for (const emitter of this.emitters.values()) {
+      emitter.dispose();
+    }
+    this.emitters.clear();
+    
+    for (const d of this.disposables) {
+      d.dispose();
+    }
+    this.disposables.length = 0;
+  }
+
+  private getOrCreateEmitter(event: string): vscode.EventEmitter<unknown> {
+    let emitter = this.emitters.get(event);
+    if (!emitter) {
+      emitter = new vscode.EventEmitter<unknown>();
+      this.emitters.set(event, emitter);
+      this.disposables.push(emitter);
+    }
+    return emitter;
+  }
+}
+
+/**
+ * Factory function for creating event bus
+ */
+export function createEventBus(): EventBus {
+  return new EventBus();
+}

package/src/infrastructure/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Infrastructure module exports
+ * 
+ * Core utilities and services used across the extension.
+ */
+
+export { Logger, createLogger } from './logger.js';
+export { DisposableManager, createDisposableManager } from './disposable-manager.js';
+export { ServiceContainer, ServiceKeys, createServiceContainer } from './service-container.js';
+export { EventBus, createEventBus } from './event-bus.js';