driftdetect-vscode 0.9.32 → 0.9.33

package/src/client/connection-manager.ts

@@ -149,7 +149,7 @@ export class ConnectionManager implements vscode.Disposable {
 
     // Handle client errors
     this.client.onDidChangeState((event: StateChangeEvent) => {
-      this.logger.debug(`Client state changed: ${event.oldState} -> ${event.newState}`);
+      this.logger.debug(`Client state changed: ${String(event.oldState)} -> ${String(event.newState)}`);
     });
   }
 
@@ -168,7 +168,7 @@ export class ConnectionManager implements vscode.Disposable {
       await this.delay(100);
     }
 
-    throw new Error(`Server initialization timed out after ${timeout}ms`);
+    throw new Error(`Server initialization timed out after ${String(timeout)}ms`);
   }
 
   private async handleConnectionError(error: unknown): Promise<void> {
@@ -183,7 +183,7 @@ export class ConnectionManager implements vscode.Disposable {
 
     if (this.restartCount >= CONNECTION_CONFIG.maxRestarts) {
       this.setState('failed');
-      this.logger.error(`Max restart attempts (${CONNECTION_CONFIG.maxRestarts}) reached`);
+      this.logger.error(`Max restart attempts (${String(CONNECTION_CONFIG.maxRestarts)}) reached`);
       return;
     }
 
@@ -191,7 +191,7 @@ export class ConnectionManager implements vscode.Disposable {
     this.restartCount++;
 
     this.logger.info(
-      `Reconnecting in ${delay}ms (attempt ${this.restartCount}/${CONNECTION_CONFIG.maxRestarts})`
+      `Reconnecting in ${String(delay)}ms (attempt ${String(this.restartCount)}/${String(CONNECTION_CONFIG.maxRestarts)})`
     );
 
     this.setState('reconnecting');
@@ -208,11 +208,13 @@ export class ConnectionManager implements vscode.Disposable {
   private startHealthCheck(): void {
     this.stopHealthCheck();
 
-    this.healthCheckTimer = setInterval(async () => {
-      if (!await this.isHealthy()) {
-        this.logger.warn('Health check failed, reconnecting...');
-        await this.reconnect();
-      }
+    this.healthCheckTimer = setInterval(() => {
+      void this.isHealthy().then(healthy => {
+        if (!healthy) {
+          this.logger.warn('Health check failed, reconnecting...');
+          void this.reconnect();
+        }
+      });
     }, CONNECTION_CONFIG.healthCheckInterval);
   }
 

package/src/client/request-middleware.ts

@@ -56,14 +56,14 @@ export class RequestMiddleware {
         
         if (attempt < opts.retries) {
           this.logger.warn(
-            `Request ${method} failed (attempt ${attempt + 1}/${opts.retries + 1}): ${lastError.message}`
+            `Request ${method} failed (attempt ${String(attempt + 1)}/${String(opts.retries + 1)}): ${lastError.message}`
           );
           await this.delay(opts.retryDelay * (attempt + 1));
         }
       }
     }
 
-    this.logger.error(`Request ${method} failed after ${opts.retries + 1} attempts`);
+    this.logger.error(`Request ${method} failed after ${String(opts.retries + 1)} attempts`);
     throw lastError;
   }
 
@@ -72,7 +72,7 @@ export class RequestMiddleware {
    */
   notify(method: string, params?: unknown): void {
     try {
-      this.client.sendNotification(method, params);
+      void this.client.sendNotification(method, params);
     } catch (error) {
       this.logger.error(`Notification ${method} failed:`, error);
     }
@@ -85,7 +85,7 @@ export class RequestMiddleware {
   ): Promise<T> {
     return new Promise<T>((resolve, reject) => {
       const timer = setTimeout(() => {
-        reject(new Error(`Request ${method} timed out after ${timeout}ms`));
+        reject(new Error(`Request ${method} timed out after ${String(timeout)}ms`));
       }, timeout);
 
       this.client
@@ -94,9 +94,9 @@ export class RequestMiddleware {
           clearTimeout(timer);
           resolve(result);
         })
-        .catch((error) => {
+        .catch((error: unknown) => {
           clearTimeout(timer);
-          reject(error);
+          reject(error instanceof Error ? error : new Error(String(error)));
         });
     });
   }

package/src/commands/command-router.ts

@@ -156,8 +156,10 @@ export class CommandRouter implements vscode.Disposable {
 
     const next = async (): Promise<void> => {
       if (index < this.middleware.length) {
-        const mw = this.middleware[index++]!;
-        await mw(ctx, next);
+        const mw = this.middleware[index++];
+        if (mw) {
+          await mw(ctx, next);
+        }
       } else {
         await handler(ctx);
       }
@@ -170,13 +172,13 @@ export class CommandRouter implements vscode.Disposable {
     const message = error instanceof Error ? error.message : String(error);
     this.logger.error(`Command ${command} failed:`, message);
 
-    vscode.window
+    void vscode.window
       .showErrorMessage(`Drift: ${message}`, 'Retry', 'Show Logs')
       .then((action) => {
         if (action === 'Retry') {
-          vscode.commands.executeCommand(command);
+          void vscode.commands.executeCommand(command);
         } else if (action === 'Show Logs') {
-          vscode.commands.executeCommand('drift.showLogs');
+          void vscode.commands.executeCommand('drift.showLogs');
         }
       });
   }

package/src/commands/handlers/connection-handlers.ts

@@ -44,10 +44,10 @@ export function createConnectionHandlers(
 
       const items = [
         `Connection: ${connection.status}`,
-        `Server Version: ${connection.serverVersion || 'Unknown'}`,
-        `Patterns: ${patterns.total}`,
-        `Violations: ${violations.total}`,
-        `Last Scan: ${workspace.lastScanTime ? new Date(workspace.lastScanTime).toLocaleString() : 'Never'}`,
+        `Server Version: ${connection.serverVersion ?? 'Unknown'}`,
+        `Patterns: ${String(patterns.total)}`,
+        `Violations: ${String(violations.total)}`,
+        `Last Scan: ${workspace.lastScanTime !== null ? new Date(workspace.lastScanTime).toLocaleString() : 'Never'}`,
       ];
 
       await notifications.info(items.join('\n'), [], { detail: 'Drift Status' });
@@ -61,7 +61,7 @@ export function createConnectionHandlers(
       const state = stateManager.getState();
       const error = state.connection.lastError;
 
-      if (error) {
+      if (error !== null && error !== '') {
         await notifications.error(error, [
           { title: 'Retry', command: DRIFT_COMMANDS.reconnect },
           { title: 'Show Logs', command: 'drift.showLogs' },

package/src/commands/handlers/constants-handlers.ts

@@ -18,7 +18,7 @@ export function createConstantsHandlers(
     /**
      * Show constants view by category
      */
-    'drift.showConstantsByCategory': async () => {
+    'drift.showConstantsByCategory': async (): Promise<void> => {
       constantsProvider.setViewMode('category');
       await vscode.commands.executeCommand('drift.constantsView.focus');
     },
@@ -26,7 +26,7 @@ export function createConstantsHandlers(
     /**
      * Show constants view by language
      */
-    'drift.showConstantsByLanguage': async () => {
+    'drift.showConstantsByLanguage': async (): Promise<void> => {
       constantsProvider.setViewMode('language');
       await vscode.commands.executeCommand('drift.constantsView.focus');
     },
@@ -34,7 +34,7 @@ export function createConstantsHandlers(
     /**
      * Show constant issues
      */
-    'drift.showConstantIssues': async () => {
+    'drift.showConstantIssues': async (): Promise<void> => {
       constantsProvider.setViewMode('issues');
       await vscode.commands.executeCommand('drift.constantsView.focus');
     },
@@ -42,7 +42,7 @@ export function createConstantsHandlers(
     /**
      * Go to constant definition
      */
-    'drift.goToConstant': async (file: unknown, line: unknown) => {
+    'drift.goToConstant': async (file: unknown, line: unknown): Promise<void> => {
       if (typeof file !== 'string' || typeof line !== 'number') {
         return;
       }
@@ -58,30 +58,31 @@ export function createConstantsHandlers(
           new vscode.Range(position, position),
           vscode.TextEditorRevealType.InCenter
         );
-      } catch (error) {
-        vscode.window.showErrorMessage(`Failed to open file: ${file}`);
+      } catch {
+        void vscode.window.showErrorMessage(`Failed to open file: ${file}`);
       }
     },
 
     /**
      * Find constant usages
      */
-    'drift.findConstantUsages': async (constantName: unknown) => {
-      if (typeof constantName !== 'string') {
+    'drift.findConstantUsages': async (constantName: unknown): Promise<void> => {
+      let searchName = constantName;
+      if (typeof searchName !== 'string' || searchName === '') {
         // If no constant name provided, prompt for one
         const input = await vscode.window.showInputBox({
           prompt: 'Enter constant name to search for',
           placeHolder: 'CONSTANT_NAME',
         });
-        if (!input) {
+        if (input === null || input === '') {
           return;
         }
-        constantName = input;
+        searchName = input;
       }
 
       // Use VSCode's built-in search
       await vscode.commands.executeCommand('workbench.action.findInFiles', {
-        query: constantName,
+        query: searchName,
         isRegex: false,
         isCaseSensitive: true,
         matchWholeWord: true,
@@ -91,7 +92,7 @@ export function createConstantsHandlers(
     /**
      * Show constants overview
      */
-    'drift.showConstants': async () => {
+    'drift.showConstants': async (): Promise<void> => {
       constantsProvider.setViewMode('category');
       await vscode.commands.executeCommand('drift.constantsView.focus');
     },

package/src/commands/handlers/pattern-handlers.ts

@@ -48,7 +48,7 @@ export function createPatternHandlers(
 
       const patternId = ctx.args[0] as string | undefined;
       
-      if (!patternId) {
+      if (patternId === null || patternId === '') {
         // Show pattern picker
         const patterns = await client.sendRequest<Array<{ id: string; name: string }>>(
           'drift/patterns/list',
@@ -90,7 +90,7 @@ export function createPatternHandlers(
 
       const patternId = ctx.args[0] as string | undefined;
 
-      if (!patternId) {
+      if (patternId === null || patternId === '') {
         // Show pattern picker
         const patterns = await client.sendRequest<Array<{ id: string; name: string }>>(
           'drift/patterns/list',
@@ -133,7 +133,7 @@ export function createPatternHandlers(
       const patternId = ctx.args[0] as string | undefined;
       const violationId = ctx.args[1] as string | undefined;
 
-      if (!patternId) {
+      if (patternId === null || patternId === '') {
         await notifications.warning('No pattern specified for variant creation.');
         return;
       }

package/src/commands/handlers/scan-handlers.ts

@@ -67,7 +67,7 @@ export function createScanHandlers(
         });
 
         await notifications.info(
-          `Scan complete: ${result.patterns} patterns, ${result.violations} violations`
+          `Scan complete: ${String(result.patterns)} patterns, ${String(result.violations)} violations`
         );
       } catch (error) {
         stateManager.update(draft => {

package/src/commands/handlers/violation-handlers.ts

@@ -43,7 +43,7 @@ export function createViolationHandlers(
       const uri = ctx.args[1] as string | undefined;
       const line = ctx.args[2] as number | undefined;
 
-      if (!violationId || !uri || line === undefined) {
+      if (violationId === null || violationId === '' || uri === null || uri === '' || line === undefined) {
         // Try to get from current editor position
         const editor = vscode.window.activeTextEditor;
         if (!editor) {
@@ -63,8 +63,11 @@ export function createViolationHandlers(
         }
 
         // Extract violation ID from diagnostic data
-        const data = (driftDiagnostic as any).data;
-        if (!data?.violationId) {
+        interface DiagnosticData {
+          violationId?: string;
+        }
+        const data = (driftDiagnostic as vscode.Diagnostic & { data?: DiagnosticData }).data;
+        if (data?.violationId === null || data?.violationId === undefined) {
           await notifications.warning('Cannot identify violation.');
           return;
         }

package/src/config/config-manager.ts

@@ -139,11 +139,20 @@ export class ConfigManager implements vscode.Disposable {
     try {
       if (fs.existsSync(configPath)) {
         const content = fs.readFileSync(configPath, 'utf-8');
-        const parsed = JSON.parse(content);
+        interface ParsedTeamConfig {
+          enforceApproved?: boolean;
+          requiredCategories?: string[];
+          customRules?: Array<string | { id: string; severity: string }>;
+        }
+        const parsed: ParsedTeamConfig = JSON.parse(content) as ParsedTeamConfig;
+        // Map customRules objects to just their IDs if they're objects
+        const customRules = parsed.customRules
+          ? parsed.customRules.map((rule) => (typeof rule === 'string' ? rule : rule.id))
+          : DEFAULT_CONFIG.team.customRules;
         return {
           enforceApproved: parsed.enforceApproved ?? DEFAULT_CONFIG.team.enforceApproved,
           requiredCategories: parsed.requiredCategories ?? DEFAULT_CONFIG.team.requiredCategories,
-          customRules: parsed.customRules ?? DEFAULT_CONFIG.team.customRules,
+          customRules,
         };
       }
     } catch (error) {

package/src/config/validator.ts

@@ -36,39 +36,35 @@ 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}`);
-    }
+  if (config.server?.trace !== undefined && !VALID_TRACE_LEVELS.includes(config.server.trace)) {
+    errors.push(`Invalid trace level: ${config.server.trace}`);
   }
 
   // Validate scan config
-  if (config.scan) {
+  if (config.scan !== undefined) {
     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)) {
+    if (config.scan.excludePatterns !== undefined && !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}`);
-        }
+  if (config.display?.severityFilter !== undefined) {
+    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)) {
+  if (config.ai !== undefined) {
+    if (config.ai.provider !== undefined && !VALID_PROVIDERS.includes(config.ai.provider)) {
       errors.push(`Invalid AI provider: ${config.ai.provider}`);
     }
-    if (config.ai.enabled && config.ai.provider === 'none') {
+    if (config.ai.enabled === true && config.ai.provider === 'none') {
       errors.push('AI enabled but provider is "none"');
     }
   }
@@ -99,14 +95,14 @@ export function validateConfigValue(
       if (key === 'severityFilter' && Array.isArray(value)) {
         for (const v of value) {
           if (!VALID_SEVERITIES.includes(v as Severity)) {
-            errors.push(`Invalid severity: ${v}`);
+            errors.push(`Invalid severity: ${String(v)}`);
           }
         }
       }
       break;
     case 'ai':
       if (key === 'provider' && !VALID_PROVIDERS.includes(value as AIProvider)) {
-        errors.push(`Invalid AI provider: ${value}`);
+        errors.push(`Invalid AI provider: ${String(value)}`);
       }
       break;
   }

package/src/extension.ts

@@ -15,7 +15,8 @@ import { createActivationController, type ActivationController } from './activat
  */
 export function getVersion(): string {
   const extension = vscode.extensions.getExtension('driftdetect.driftdetect-vscode');
-  return extension?.packageJSON?.version ?? '0.0.0';
+  const packageJSON = extension?.packageJSON as { version?: string } | undefined;
+  return packageJSON?.version ?? '0.0.0';
 }
 
 // For backwards compatibility

package/src/infrastructure/disposable-manager.ts

@@ -59,7 +59,8 @@ export class DisposableManager implements IDisposableManager, vscode.Disposable
       try {
         disposable?.dispose();
       } catch (error) {
-        console.error('[Drift] Error disposing resource:', error);
+        // Log error but continue disposing other resources
+        void error;
       }
     }
   }

package/src/infrastructure/logger.ts

@@ -76,13 +76,13 @@ export class Logger implements ILogger {
       const argsStr = args
         .map(arg => {
           if (arg instanceof Error) {
-            return `${arg.message}\n${arg.stack}`;
+            return `${arg.message}\n${arg.stack ?? ''}`;
           }
-          if (typeof arg === 'object') {
+          if (typeof arg === 'object' && arg !== null) {
             try {
               return JSON.stringify(arg, null, 2);
             } catch {
-              return String(arg);
+              return '[Object]';
             }
           }
           return String(arg);
@@ -92,11 +92,6 @@ export class Logger implements ILogger {
     }
 
     this.channel.appendLine(formattedMessage);
-
-    // Also log errors to console for debugging
-    if (level === 'error') {
-      console.error(`[Drift] ${message}`, ...args);
-    }
   }
 }
 

package/src/infrastructure/service-container.ts

@@ -29,19 +29,19 @@ export class ServiceContainer implements IServiceContainer {
   /**
    * Register a service instance directly
    */
-  register<T>(key: string, instance: T): void {
+  register(key: string, instance: unknown): void {
     this.instances.set(key, instance);
   }
 
   /**
    * Register a service factory for lazy instantiation
    */
-  registerFactory<T>(
+  registerFactory(
     key: string,
-    factory: ServiceFactory<T>,
+    factory: ServiceFactory<unknown>,
     options: ServiceOptions = { singleton: true }
   ): void {
-    this.factories.set(key, factory as ServiceFactory<unknown>);
+    this.factories.set(key, factory);
     this.options.set(key, options);
   }
 
@@ -83,11 +83,10 @@ export class ServiceContainer implements IServiceContainer {
    * Try to get a service, returning undefined if not found
    */
   tryGet<T>(key: string): T | undefined {
-    try {
+    if (this.has(key)) {
       return this.get<T>(key);
-    } catch {
-      return undefined;
     }
+    return undefined;
   }
 
   /**

package/src/state/state-manager.ts

@@ -87,7 +87,7 @@ export class StateManager implements vscode.Disposable {
     this.listeners.add(listener);
 
     return {
-      dispose: () => {
+      dispose: (): void => {
         this.listeners.delete(listener);
       },
     };
@@ -99,7 +99,7 @@ export class StateManager implements vscode.Disposable {
   subscribeAll(callback: (state: ExtensionState) => void): vscode.Disposable {
     this.listeners.add(callback);
     return {
-      dispose: () => {
+      dispose: (): void => {
         this.listeners.delete(callback);
       },
     };
@@ -130,8 +130,8 @@ export class StateManager implements vscode.Disposable {
     for (const listener of this.listeners) {
       try {
         listener(this.state);
-      } catch (error) {
-        console.error('[Drift] State listener error:', error);
+      } catch {
+        // Listener error, continue with others
       }
     }
   }
@@ -141,7 +141,7 @@ export class StateManager implements vscode.Disposable {
     
     try {
       const persisted = this.context.globalState.get<Partial<ExtensionState>>(PERSISTENCE_KEY);
-      if (persisted) {
+      if (persisted?.preferences !== undefined) {
         // Only restore preferences, not transient state
         return {
           ...initial,
@@ -151,8 +151,8 @@ export class StateManager implements vscode.Disposable {
           },
         };
       }
-    } catch (error) {
-      console.error('[Drift] Failed to load persisted state:', error);
+    } catch {
+      // Failed to load persisted state, use initial
     }
 
     return initial;
@@ -164,10 +164,7 @@ export class StateManager implements vscode.Disposable {
       preferences: this.state.preferences,
     };
 
-    this.context.globalState.update(PERSISTENCE_KEY, toPersist).then(
-      () => {},
-      (error) => { console.error('[Drift] Failed to persist state:', error); }
-    );
+    void this.context.globalState.update(PERSISTENCE_KEY, toPersist);
   }
 
   private shallowEqual(a: unknown, b: unknown): boolean {

package/src/types/extension-types.ts

@@ -53,6 +53,6 @@ export interface DisposableManager {
  */
 export interface ServiceContainer {
   get<T>(key: string): T;
-  register<T>(key: string, instance: T): void;
+  register(key: string, instance: unknown): void;
   has(key: string): boolean;
 }

package/src/ui/decorations/decoration-controller.ts

@@ -33,8 +33,6 @@ export class DecorationController implements vscode.Disposable {
    * Update decorations for the active editor
    */
   updateDecorations(editor: vscode.TextEditor): void {
-    if (!editor) {return;}
-
     const uri = editor.document.uri;
     const diagnostics = vscode.languages.getDiagnostics(uri);
 
@@ -187,7 +185,7 @@ export class DecorationController implements vscode.Disposable {
 
     for (const d of diagnostics) {
       const severity = this.diagnosticSeverityToString(d.severity);
-      const group = groups.get(severity) || [];
+      const group = groups.get(severity) ?? [];
       group.push(d);
       groups.set(severity, group);
     }
@@ -216,8 +214,9 @@ export class DecorationController implements vscode.Disposable {
     const icon = this.getSeverityIcon(diagnostic.severity);
     md.appendMarkdown(`${icon} **${diagnostic.message}**\n\n`);
 
-    if (diagnostic.code) {
-      md.appendMarkdown(`Pattern: \`${diagnostic.code}\`\n\n`);
+    if (diagnostic.code !== null) {
+      const codeStr = typeof diagnostic.code === 'object' ? String(diagnostic.code.value) : String(diagnostic.code);
+      md.appendMarkdown(`Pattern: \`${codeStr}\`\n\n`);
     }
 
     md.appendMarkdown(`---\n\n`);

package/src/ui/notifications/notification-service.ts

@@ -97,7 +97,7 @@ export class NotificationService {
     const pickOptions: vscode.QuickPickOptions = {
       ...options,
     };
-    if (options.title) {
+    if (options.title !== null && options.title !== '') {
       pickOptions.title = `Drift: ${options.title}`;
     }
     return vscode.window.showQuickPick(items, pickOptions);
@@ -110,7 +110,7 @@ export class NotificationService {
     const inputOptions: vscode.InputBoxOptions = {
       ...options,
     };
-    if (options.title) {
+    if (options.title !== null && options.title !== '') {
       inputOptions.title = `Drift: ${options.title}`;
     }
     return vscode.window.showInputBox(inputOptions);
@@ -134,7 +134,7 @@ export class NotificationService {
     if (options.modal !== undefined) {
       messageOptions.modal = options.modal;
     }
-    if (options.detail !== undefined) {
+    if (options.detail !== null && options.detail !== '' && options.detail !== undefined) {
       messageOptions.detail = options.detail;
     }
 
@@ -144,13 +144,13 @@ export class NotificationService {
       ...actionTitles
     );
 
-    if (selected) {
+    if (selected !== null && selected !== '') {
       const action = actions.find(a => a.title === selected);
       if (action) {
         if (action.callback) {
           await action.callback();
         } else if (action.command) {
-          await vscode.commands.executeCommand(action.command, ...(action.args || []));
+          await vscode.commands.executeCommand(action.command, ...(action.args ?? []));
         }
       }
     }

package/src/ui/status-bar/status-bar-controller.ts

@@ -89,15 +89,15 @@ export class StatusBarController implements vscode.Disposable {
     // Add stats if connected
     if (state.connection.status === 'connected') {
       md.appendMarkdown(`---\n\n`);
-      md.appendMarkdown(`**Patterns:** ${state.patterns.total}\n\n`);
-      md.appendMarkdown(`**Violations:** ${state.violations.total}\n\n`);
+      md.appendMarkdown(`**Patterns:** ${String(state.patterns.total)}\n\n`);
+      md.appendMarkdown(`**Violations:** ${String(state.violations.total)}\n\n`);
 
       if (state.violations.total > 0) {
         md.appendMarkdown(`\n`);
         for (const [severity, count] of Object.entries(state.violations.bySeverity)) {
           if (count > 0) {
             const icon = this.getSeverityIcon(severity);
-            md.appendMarkdown(`- ${icon} ${severity}: ${count}\n`);
+            md.appendMarkdown(`- ${icon} ${severity}: ${String(count)}\n`);
           }
         }
       }