driftdetect-vscode 0.8.2

package/src/infrastructure/logger.ts

@@ -0,0 +1,108 @@
+/**
+ * Logger - Centralized logging with output channel integration
+ * 
+ * Single responsibility: Provide structured logging to VS Code output channel.
+ */
+
+import * as vscode from 'vscode';
+
+import type { Logger as ILogger } from '../types/index.js';
+
+/**
+ * Log levels for filtering
+ */
+type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+
+const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+};
+
+/**
+ * Logger implementation with VS Code output channel
+ */
+export class Logger implements ILogger {
+  private readonly channel: vscode.OutputChannel;
+  private readonly minLevel: LogLevel;
+
+  constructor(channelName: string, minLevel: LogLevel = 'info') {
+    this.channel = vscode.window.createOutputChannel(channelName);
+    this.minLevel = minLevel;
+  }
+
+  error(message: string, ...args: unknown[]): void {
+    this.log('error', message, args);
+  }
+
+  warn(message: string, ...args: unknown[]): void {
+    this.log('warn', message, args);
+  }
+
+  info(message: string, ...args: unknown[]): void {
+    this.log('info', message, args);
+  }
+
+  debug(message: string, ...args: unknown[]): void {
+    this.log('debug', message, args);
+  }
+
+  /**
+   * Show the output channel
+   */
+  show(): void {
+    this.channel.show();
+  }
+
+  /**
+   * Dispose the output channel
+   */
+  dispose(): void {
+    this.channel.dispose();
+  }
+
+  private log(level: LogLevel, message: string, args: unknown[]): void {
+    if (LOG_LEVEL_PRIORITY[level] > LOG_LEVEL_PRIORITY[this.minLevel]) {
+      return;
+    }
+
+    const timestamp = new Date().toISOString();
+    const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
+    
+    let formattedMessage = `${prefix} ${message}`;
+    
+    if (args.length > 0) {
+      const argsStr = args
+        .map(arg => {
+          if (arg instanceof Error) {
+            return `${arg.message}\n${arg.stack}`;
+          }
+          if (typeof arg === 'object') {
+            try {
+              return JSON.stringify(arg, null, 2);
+            } catch {
+              return String(arg);
+            }
+          }
+          return String(arg);
+        })
+        .join(' ');
+      formattedMessage += ` ${argsStr}`;
+    }
+
+    this.channel.appendLine(formattedMessage);
+
+    // Also log errors to console for debugging
+    if (level === 'error') {
+      console.error(`[Drift] ${message}`, ...args);
+    }
+  }
+}
+
+/**
+ * Factory function for creating loggers
+ */
+export function createLogger(channelName: string = 'Drift', minLevel: LogLevel = 'info'): Logger {
+  return new Logger(channelName, minLevel);
+}

package/src/infrastructure/service-container.ts

@@ -0,0 +1,123 @@
+/**
+ * ServiceContainer - Dependency injection container
+ * 
+ * Single responsibility: Manage service instances and dependencies.
+ */
+
+import type { ServiceContainer as IServiceContainer } from '../types/index.js';
+
+/**
+ * Service registration options
+ */
+interface ServiceOptions {
+  singleton?: boolean;
+}
+
+/**
+ * Service factory function type
+ */
+type ServiceFactory<T> = (container: ServiceContainer) => T;
+
+/**
+ * Simple dependency injection container
+ */
+export class ServiceContainer implements IServiceContainer {
+  private readonly instances = new Map<string, unknown>();
+  private readonly factories = new Map<string, ServiceFactory<unknown>>();
+  private readonly options = new Map<string, ServiceOptions>();
+
+  /**
+   * Register a service instance directly
+   */
+  register<T>(key: string, instance: T): void {
+    this.instances.set(key, instance);
+  }
+
+  /**
+   * Register a service factory for lazy instantiation
+   */
+  registerFactory<T>(
+    key: string,
+    factory: ServiceFactory<T>,
+    options: ServiceOptions = { singleton: true }
+  ): void {
+    this.factories.set(key, factory as ServiceFactory<unknown>);
+    this.options.set(key, options);
+  }
+
+  /**
+   * Get a service instance
+   */
+  get<T>(key: string): T {
+    // Check for existing instance
+    if (this.instances.has(key)) {
+      return this.instances.get(key) as T;
+    }
+
+    // Check for factory
+    const factory = this.factories.get(key);
+    if (!factory) {
+      throw new Error(`Service not registered: ${key}`);
+    }
+
+    // Create instance
+    const instance = factory(this) as T;
+
+    // Cache if singleton
+    const opts = this.options.get(key);
+    if (opts?.singleton !== false) {
+      this.instances.set(key, instance);
+    }
+
+    return instance;
+  }
+
+  /**
+   * Check if a service is registered
+   */
+  has(key: string): boolean {
+    return this.instances.has(key) || this.factories.has(key);
+  }
+
+  /**
+   * Try to get a service, returning undefined if not found
+   */
+  tryGet<T>(key: string): T | undefined {
+    try {
+      return this.get<T>(key);
+    } catch {
+      return undefined;
+    }
+  }
+
+  /**
+   * Clear all registered services
+   */
+  clear(): void {
+    this.instances.clear();
+    this.factories.clear();
+    this.options.clear();
+  }
+}
+
+/**
+ * Service keys for type-safe access
+ */
+export const ServiceKeys = {
+  Logger: 'logger',
+  StateManager: 'stateManager',
+  ConfigManager: 'configManager',
+  ConnectionManager: 'connectionManager',
+  LanguageClient: 'languageClient',
+  CommandRouter: 'commandRouter',
+  TelemetryService: 'telemetryService',
+  StatusBar: 'statusBar',
+  DecorationController: 'decorationController',
+} as const;
+
+/**
+ * Factory function for creating service containers
+ */
+export function createServiceContainer(): ServiceContainer {
+  return new ServiceContainer();
+}

package/src/state/index.ts

@@ -0,0 +1,7 @@
+/**
+ * State management module exports
+ */
+
+export { StateManager, createStateManager } from './state-manager.js';
+export { createInitialState } from './initial-state.js';
+export * from './selectors.js';

package/src/state/initial-state.ts

@@ -0,0 +1,60 @@
+/**
+ * Initial state factory
+ * 
+ * Single responsibility: Provide default state values.
+ */
+
+import type { ExtensionState } from '../types/index.js';
+
+/**
+ * Create the initial extension state
+ */
+export function createInitialState(): ExtensionState {
+  return {
+    connection: {
+      status: 'disconnected',
+      serverVersion: null,
+      lastError: null,
+      restartCount: 0,
+    },
+    workspace: {
+      initialized: false,
+      projectRoot: null,
+      configPath: null,
+      lastScanTime: null,
+      scanning: false,
+    },
+    patterns: {
+      total: 0,
+      byCategory: {},
+      byStatus: {
+        discovered: 0,
+        approved: 0,
+        ignored: 0,
+      },
+      lastUpdated: null,
+    },
+    violations: {
+      total: 0,
+      bySeverity: {
+        error: 0,
+        warning: 0,
+        info: 0,
+        hint: 0,
+      },
+      activeFile: null,
+      activeFileCount: 0,
+    },
+    ui: {
+      statusBarVisible: true,
+      sidebarExpanded: false,
+      activePanel: null,
+    },
+    preferences: {
+      autoScan: true,
+      showInlineHints: true,
+      severityFilter: ['error', 'warning'],
+      categoryFilter: [],
+    },
+  };
+}

package/src/state/selectors.ts

@@ -0,0 +1,126 @@
+/**
+ * State selectors - Reusable state accessors
+ * 
+ * Single responsibility: Provide typed access to state slices.
+ */
+
+import type { StateSelector } from '../types/index.js';
+
+// ============================================================================
+// Connection Selectors
+// ============================================================================
+
+export const selectConnectionStatus: StateSelector<string> = 
+  (state) => state.connection.status;
+
+export const selectIsConnected: StateSelector<boolean> = 
+  (state) => state.connection.status === 'connected';
+
+export const selectConnectionError: StateSelector<string | null> = 
+  (state) => state.connection.lastError;
+
+export const selectServerVersion: StateSelector<string | null> = 
+  (state) => state.connection.serverVersion;
+
+// ============================================================================
+// Workspace Selectors
+// ============================================================================
+
+export const selectIsInitialized: StateSelector<boolean> = 
+  (state) => state.workspace.initialized;
+
+export const selectProjectRoot: StateSelector<string | null> = 
+  (state) => state.workspace.projectRoot;
+
+export const selectIsScanning: StateSelector<boolean> = 
+  (state) => state.workspace.scanning;
+
+export const selectLastScanTime: StateSelector<number | null> = 
+  (state) => state.workspace.lastScanTime;
+
+// ============================================================================
+// Pattern Selectors
+// ============================================================================
+
+export const selectPatternTotal: StateSelector<number> = 
+  (state) => state.patterns.total;
+
+export const selectPatternsByCategory: StateSelector<Record<string, number>> = 
+  (state) => state.patterns.byCategory;
+
+export const selectPatternsByStatus: StateSelector<Record<string, number>> = 
+  (state) => state.patterns.byStatus;
+
+export const selectPatternsLastUpdated: StateSelector<number | null> = 
+  (state) => state.patterns.lastUpdated;
+
+// ============================================================================
+// Violation Selectors
+// ============================================================================
+
+export const selectViolationTotal: StateSelector<number> = 
+  (state) => state.violations.total;
+
+export const selectViolationsBySeverity: StateSelector<Record<string, number>> = 
+  (state) => state.violations.bySeverity;
+
+export const selectActiveFileViolations: StateSelector<number> = 
+  (state) => state.violations.activeFileCount;
+
+export const selectActiveFile: StateSelector<string | null> = 
+  (state) => state.violations.activeFile;
+
+// ============================================================================
+// UI Selectors
+// ============================================================================
+
+export const selectStatusBarVisible: StateSelector<boolean> = 
+  (state) => state.ui.statusBarVisible;
+
+export const selectSidebarExpanded: StateSelector<boolean> = 
+  (state) => state.ui.sidebarExpanded;
+
+export const selectActivePanel: StateSelector<string | null> = 
+  (state) => state.ui.activePanel;
+
+// ============================================================================
+// Preferences Selectors
+// ============================================================================
+
+export const selectAutoScan: StateSelector<boolean> = 
+  (state) => state.preferences.autoScan;
+
+export const selectShowInlineHints: StateSelector<boolean> = 
+  (state) => state.preferences.showInlineHints;
+
+export const selectSeverityFilter: StateSelector<string[]> = 
+  (state) => state.preferences.severityFilter;
+
+export const selectCategoryFilter: StateSelector<string[]> = 
+  (state) => state.preferences.categoryFilter;
+
+// ============================================================================
+// Composite Selectors
+// ============================================================================
+
+export const selectStatusBarData: StateSelector<{
+  status: string;
+  violations: number;
+  scanning: boolean;
+}> = (state) => ({
+  status: state.connection.status,
+  violations: state.violations.total,
+  scanning: state.workspace.scanning,
+});
+
+export const selectHealthSummary: StateSelector<{
+  connected: boolean;
+  patterns: number;
+  violations: number;
+  lastScan: number | null;
+}> = (state) => ({
+  connected: state.connection.status === 'connected',
+  patterns: state.patterns.total,
+  violations: state.violations.total,
+  lastScan: state.workspace.lastScanTime,
+});

package/src/state/state-manager.ts

@@ -0,0 +1,198 @@
+/**
+ * StateManager - Centralized reactive state management
+ * 
+ * Single responsibility: Manage extension state with subscriptions.
+ */
+
+import * as vscode from 'vscode';
+
+import { createInitialState } from './initial-state.js';
+
+import type {
+  ExtensionState,
+  StateUpdater,
+  StateSelector,
+  StateSubscriber,
+} from '../types/index.js';
+
+/**
+ * Persistence key for state
+ */
+const PERSISTENCE_KEY = 'drift.state';
+
+/**
+ * State manager with selector-based subscriptions
+ */
+export class StateManager implements vscode.Disposable {
+  private state: ExtensionState;
+  private readonly listeners = new Set<(state: ExtensionState) => void>();
+  private readonly context: vscode.ExtensionContext;
+
+  constructor(context: vscode.ExtensionContext) {
+    this.context = context;
+    this.state = this.loadState();
+  }
+
+  /**
+   * Get current state (readonly)
+   */
+  getState(): Readonly<ExtensionState> {
+    return this.state;
+  }
+
+  /**
+   * Update state with an updater function
+   */
+  update(updater: StateUpdater): void {
+    // Create a shallow copy for the updater
+    const draft = this.createDraft();
+    updater(draft);
+    
+    // Apply changes
+    this.state = draft;
+    this.notifyListeners();
+    this.persistState();
+  }
+
+  /**
+   * Batch multiple updates
+   */
+  batch(updaters: StateUpdater[]): void {
+    const draft = this.createDraft();
+    for (const updater of updaters) {
+      updater(draft);
+    }
+    this.state = draft;
+    this.notifyListeners();
+    this.persistState();
+  }
+
+  /**
+   * Subscribe to state changes with a selector
+   */
+  subscribe<T>(
+    selector: StateSelector<T>,
+    callback: StateSubscriber<T>
+  ): vscode.Disposable {
+    let previousValue = selector(this.state);
+
+    const listener = (state: ExtensionState): void => {
+      const newValue = selector(state);
+      if (!this.shallowEqual(previousValue, newValue)) {
+        previousValue = newValue;
+        callback(newValue);
+      }
+    };
+
+    this.listeners.add(listener);
+
+    return {
+      dispose: () => {
+        this.listeners.delete(listener);
+      },
+    };
+  }
+
+  /**
+   * Subscribe to all state changes
+   */
+  subscribeAll(callback: (state: ExtensionState) => void): vscode.Disposable {
+    this.listeners.add(callback);
+    return {
+      dispose: () => {
+        this.listeners.delete(callback);
+      },
+    };
+  }
+
+  /**
+   * Reset state to initial values
+   */
+  reset(): void {
+    this.state = createInitialState();
+    this.notifyListeners();
+    this.persistState();
+  }
+
+  /**
+   * Dispose the state manager
+   */
+  dispose(): void {
+    this.listeners.clear();
+  }
+
+  private createDraft(): ExtensionState {
+    // Deep clone for immutability
+    return JSON.parse(JSON.stringify(this.state));
+  }
+
+  private notifyListeners(): void {
+    for (const listener of this.listeners) {
+      try {
+        listener(this.state);
+      } catch (error) {
+        console.error('[Drift] State listener error:', error);
+      }
+    }
+  }
+
+  private loadState(): ExtensionState {
+    const initial = createInitialState();
+    
+    try {
+      const persisted = this.context.globalState.get<Partial<ExtensionState>>(PERSISTENCE_KEY);
+      if (persisted) {
+        // Only restore preferences, not transient state
+        return {
+          ...initial,
+          preferences: {
+            ...initial.preferences,
+            ...persisted.preferences,
+          },
+        };
+      }
+    } catch (error) {
+      console.error('[Drift] Failed to load persisted state:', error);
+    }
+
+    return initial;
+  }
+
+  private persistState(): void {
+    // Only persist user preferences
+    const toPersist = {
+      preferences: this.state.preferences,
+    };
+
+    this.context.globalState.update(PERSISTENCE_KEY, toPersist).then(
+      () => {},
+      (error) => { console.error('[Drift] Failed to persist state:', error); }
+    );
+  }
+
+  private shallowEqual(a: unknown, b: unknown): boolean {
+    if (a === b) {return true;}
+    if (typeof a !== typeof b) {return false;}
+    if (typeof a !== 'object' || a === null || b === null) {return false;}
+
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b as object);
+
+    if (keysA.length !== keysB.length) {return false;}
+
+    for (const key of keysA) {
+      if ((a as Record<string, unknown>)[key] !== (b as Record<string, unknown>)[key]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+}
+
+/**
+ * Factory function for creating state manager
+ */
+export function createStateManager(context: vscode.ExtensionContext): StateManager {
+  return new StateManager(context);
+}

package/src/types/config-types.ts

@@ -0,0 +1,77 @@
+/**
+ * Configuration type definitions
+ */
+
+import type { Severity } from './extension-types.js';
+
+/**
+ * Server configuration
+ */
+export interface ServerConfig {
+  path: string;
+  args: string[];
+  trace: 'off' | 'messages' | 'verbose';
+}
+
+/**
+ * Scan configuration
+ */
+export interface ScanConfig {
+  onSave: boolean;
+  onOpen: boolean;
+  debounceMs: number;
+  excludePatterns: string[];
+}
+
+/**
+ * Display configuration
+ */
+export interface DisplayConfig {
+  showStatusBar: boolean;
+  showInlineHints: boolean;
+  showGutterIcons: boolean;
+  severityFilter: Severity[];
+}
+
+/**
+ * AI provider types
+ */
+export type AIProvider = 'openai' | 'anthropic' | 'ollama' | 'none';
+
+/**
+ * AI configuration
+ */
+export interface AIConfig {
+  enabled: boolean;
+  provider: AIProvider;
+  model: string;
+}
+
+/**
+ * Team configuration (from .drift/config.json)
+ */
+export interface TeamConfig {
+  enforceApproved: boolean;
+  requiredCategories: string[];
+  customRules: string[];
+}
+
+/**
+ * Complete extension configuration
+ */
+export interface DriftConfig {
+  server: ServerConfig;
+  scan: ScanConfig;
+  display: DisplayConfig;
+  ai: AIConfig;
+  team: TeamConfig;
+}
+
+/**
+ * Configuration change event
+ */
+export interface ConfigChangeEvent {
+  section: keyof DriftConfig;
+  oldValue: unknown;
+  newValue: unknown;
+}