Building Like We Mean It: Why Architecture Matters in 2024 🏗️

// src/managers/ExtensionManager.ts - Real implementation from v1.2.0
export class ExtensionManager {
  private readonly logger = new Logger('ExtensionManager');
  private readonly configService = ConfigurationService.getInstance();
  private readonly notificationService = new NotificationService();
  private readonly keybindingService = new KeybindingNotificationService();
  private readonly disposables: Disposable[] = [];
  private activated = false;

  public async activate(context: ExtensionContext): Promise<void> {
    try {
      this.logger.info('Starting extension activation...');

      // Initialize services in dependency order (this order matters!)
      await this.configService.initialize();
      await this.notificationService.initialize();
      await this.keybindingService.initialize();

      // Register configuration change handlers
      this.setupConfigurationWatchers();

      // Clean lifecycle management
      this.disposables.forEach(disposable => {
        context.subscriptions.push(disposable);
      });

      this.activated = true;
      this.logger.info('Extension activated successfully');

      // Show subtle confirmation (debug mode only)
      if (this.configService.getLogLevel() === 'debug') {
        await this.notificationService.showInfo('Keypress Notifications ready');
      }
    } catch (error) {
      this.logger.error('Extension activation failed:', error);
      throw error; // Let VS Code handle the failure
    }
  }

  public deactivate(): void {
    this.logger.info('Deactivating extension...');
    this.disposables.forEach(disposable => disposable.dispose());
    this.activated = false;
  }

  private setupConfigurationWatchers(): void {
    // React to configuration changes without restart
    const disposable = this.configService.onConfigurationChanged(
      async (config) => {
        this.logger.debug('Configuration changed, updating services...');
        await this.keybindingService.updateConfiguration(config);
      }
    );
    this.disposables.push(disposable);
  }
}

// src/services/BaseService.ts - The foundation every service builds on
export abstract class BaseService {
  protected readonly logger: Logger;
  protected initialized = false;
  private readonly disposables: Disposable[] = [];
  private readonly startTime = Date.now();
  private initializationPromise?: Promise<void>;

  constructor(serviceName: string) {
    this.logger = new Logger(serviceName);
  }

  public async initialize(): Promise<void> {
    // Prevent multiple simultaneous initializations
    if (this.initializationPromise) {
      return this.initializationPromise;
    }

    if (this.initialized) {
      this.logger.warn(`${this.constructor.name} already initialized`);
      return;
    }

    this.initializationPromise = this.performInitialization();
    return this.initializationPromise;
  }

  private async performInitialization(): Promise<void> {
    try {
      this.logger.debug(`Initializing ${this.constructor.name}...`);
      await this.onInitialize();
      this.initialized = true;

      const initTime = Date.now() - this.startTime;
      this.logger.info(`${this.constructor.name} initialized in ${initTime}ms`);
    } catch (error) {
      this.logger.error(`Failed to initialize ${this.constructor.name}:`, error);
      throw error;
    }
  }

  public dispose(): void {
    if (!this.initialized) return;

    try {
      this.logger.debug(`Disposing ${this.constructor.name}...`);
      this.onDispose();
      this.disposables.forEach(d => d.dispose());
      this.initialized = false;
      this.logger.info(`${this.constructor.name} disposed`);
    } catch (error) {
      this.logger.error(`Error disposing ${this.constructor.name}:`, error);
    }
  }

  protected addDisposable(disposable: Disposable): void {
    this.disposables.push(disposable);
  }

  protected abstract onInitialize(): Promise<void>;
  protected abstract onDispose(): void;

  // Performance monitoring for debugging slow operations
  protected async measureTime<T>(
    operation: string, 
    fn: () => Promise<T>
  ): Promise<T> {
    const start = Date.now();
    try {
      return await fn();
    } finally {
      const duration = Date.now() - start;
      if (duration > 100) { // Log operations slower than 100ms
        this.logger.warn(`Slow operation: ${operation} took ${duration}ms`);
      } else if (duration > 50) {
        this.logger.debug(`${operation} took ${duration}ms`);
      }
    }
  }
}

export interface ExtensionConfig {
  enabled: boolean;
  logLevel: 'error' | 'warn' | 'info' | 'debug';
  minimumKeys: number;
  excludedCommands: string[];
  showCommandName: boolean;
}

export class ConfigurationService extends BaseService {
  private currentConfig: ExtensionConfig;

  public getConfiguration(): ExtensionConfig {
    return this.currentConfig;
  }

  public onConfigurationChanged(callback: (config: ExtensionConfig) => void): Disposable {
    // Reactive configuration updates!
  }
}

/**
 * Service responsible for detecting keybinding usage and showing notifications.
 *
 * This service provides:
 * - Detection of multi-key command executions
 * - Notification display for keybinding events  
 * - Configuration-based filtering and enabling/disabling
 * - Integration with VS Code's command system
 */
export class KeybindingNotificationService extends BaseService {
  private readonly notificationService = new NotificationService();
  private readonly configService = ConfigurationService.getInstance();
  private readonly keybindingReader = new KeybindingReaderService();
}

ExtensionManager (coordinator)
├── ConfigurationService (settings)
├── CommandManager (VS Code commands)  
├── KeybindingNotificationService (main logic)
│   ├── NotificationService (UI feedback)
│   └── KeybindingReaderService (parsing)
└── Logger (observability)

// NotificationService only cares about notifications
export class NotificationService extends BaseService {
  public async showInfo(message: string): Promise<string | undefined> {
    this.logger.info(`Info notification: ${message}`);
    return window.showInformationMessage(message);
  }
}

// ConfigurationService only cares about settings  
export class ConfigurationService extends BaseService {
  public getConfiguration(): ExtensionConfig {
    // Pure configuration logic
  }
}

export class KeybindingNotificationService extends BaseService {
  private readonly notificationService = new NotificationService();
  private readonly configService = ConfigurationService.getInstance();

  private async showKeybindingNotification(event: KeybindingEvent): Promise<void> {
    const message = `${event.keyCombination.formatted} detected`;
    await this.notificationService.showInfo(message);
  }
}

// Real implementation from v1.1.0 feature addition
public isCommandExcluded(commandId: string, excludedCommands: string[]): boolean {
  return excludedCommands.some(pattern => {
    if (pattern.includes('*')) {
      // Cache regex for performance (real optimization I added)
      const cacheKey = `regex_${pattern}`;
      if (!this.regexCache.has(cacheKey)) {
        this.regexCache.set(cacheKey, new RegExp(
          pattern.replace(/\*/g, '.*').replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
        ));
      }
      return this.regexCache.get(cacheKey)!.test(commandId);
    }
    return commandId === pattern;
  });
}

// ConfigurationService.test.ts - Tests that actually saved my bacon
describe('ConfigurationService', () => {
  let service: ConfigurationService;

  beforeEach(() => {
    // Clean instance for each test (real pattern I use)
    (ConfigurationService as any).instance = undefined;
    service = ConfigurationService.getInstance();
  });

  it('should validate minimum keys configuration', async () => {
    await service.initialize();

    // This test caught a user-reported edge case
    const mockConfig = { minimumKeys: -1 };
    jest.spyOn(workspace, 'getConfiguration').mockReturnValue({
      get: jest.fn().mockReturnValue(-1)
    } as any);

    await service.loadConfiguration();
    expect(service.getConfiguration().minimumKeys).toBe(1); // Auto-corrected
  });

  it('should handle malformed excluded commands gracefully', async () => {
    // Real edge case from user feedback
    const malformedCommands = [null, undefined, '', 'valid.command'];
    expect(() => {
      service.isCommandExcluded('test.command', malformedCommands);
    }).not.toThrow();
  });
});

Version 1.1.4: "Command detection works"
Version 1.1.5: "Command detection works" (but faster and more reliable)

export class ConfigurationService extends BaseService {
  private static instance: ConfigurationService | undefined;

  public static getInstance(): ConfigurationService {
    if (!ConfigurationService.instance) {
      ConfigurationService.instance = new ConfigurationService();
    }
    return ConfigurationService.instance;
  }
}

public onConfigurationChanged(callback: (config: ExtensionConfig) => void): Disposable {
  const disposable = workspace.onDidChangeConfiguration((event) => {
    if (event.affectsConfiguration(this.configSection)) {
      this.loadConfiguration();
      callback(this.currentConfig);
    }
  });

  return disposable;
}

export interface ILogger {
  error(message: string, ...args: unknown[]): void;
  warn(message: string, ...args: unknown[]): void;
  info(message: string, ...args: unknown[]): void;
  debug(message: string, ...args: unknown[]): void;
}

export interface IService {
  initialize(): Promise<void>;
  dispose(): void;
}