driftdetect-vscode 0.8.2

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

@@ -0,0 +1,167 @@
+/**
+ * Pattern command handlers
+ * 
+ * Single responsibility: Handle pattern-related commands.
+ */
+
+import * as vscode from 'vscode';
+
+import { DRIFT_COMMANDS } from '../command-definitions.js';
+
+import type { ConnectionManager } from '../../client/index.js';
+import type { NotificationService } from '../../ui/notifications/notification-service.js';
+import type { CommandRouter, CommandContext } from '../command-router.js';
+
+
+/**
+ * Pattern quick pick item with id
+ */
+interface PatternQuickPickItem extends vscode.QuickPickItem {
+  id: string;
+}
+
+/**
+ * Create pattern command handlers
+ */
+export function createPatternHandlers(
+  router: CommandRouter,
+  connectionManager: ConnectionManager,
+  notifications: NotificationService
+): void {
+  // Show patterns command
+  router.register({
+    id: DRIFT_COMMANDS.showPatterns,
+    handler: async (_ctx: CommandContext) => {
+      // Focus the patterns tree view
+      await vscode.commands.executeCommand('drift.patterns.focus');
+    },
+  });
+
+  // Approve pattern command
+  router.register({
+    id: DRIFT_COMMANDS.approvePattern,
+    handler: async (ctx: CommandContext) => {
+      const client = connectionManager.getClient();
+      if (!client) {
+        throw new Error('Not connected to server');
+      }
+
+      const patternId = ctx.args[0] as string | undefined;
+      
+      if (!patternId) {
+        // Show pattern picker
+        const patterns = await client.sendRequest<Array<{ id: string; name: string }>>(
+          'drift/patterns/list',
+          { status: 'discovered' }
+        );
+
+        if (patterns.length === 0) {
+          await notifications.info('No patterns to approve.');
+          return;
+        }
+
+        const items: PatternQuickPickItem[] = patterns.map((p: { id: string; name: string }) => ({
+          label: p.name,
+          description: p.id,
+          id: p.id,
+        }));
+
+        const selected = await notifications.quickPick(items, { title: 'Select Pattern to Approve' });
+
+        if (!selected) {return;}
+
+        await client.sendRequest('drift/patterns/approve', { id: selected.id });
+        await notifications.info(`Pattern "${selected.label}" approved.`);
+      } else {
+        await client.sendRequest('drift/patterns/approve', { id: patternId });
+        await notifications.info(`Pattern approved.`);
+      }
+    },
+  });
+
+  // Ignore pattern command
+  router.register({
+    id: DRIFT_COMMANDS.ignorePattern,
+    handler: async (ctx: CommandContext) => {
+      const client = connectionManager.getClient();
+      if (!client) {
+        throw new Error('Not connected to server');
+      }
+
+      const patternId = ctx.args[0] as string | undefined;
+
+      if (!patternId) {
+        // Show pattern picker
+        const patterns = await client.sendRequest<Array<{ id: string; name: string }>>(
+          'drift/patterns/list',
+          { status: 'discovered' }
+        );
+
+        if (patterns.length === 0) {
+          await notifications.info('No patterns to ignore.');
+          return;
+        }
+
+        const items: PatternQuickPickItem[] = patterns.map((p: { id: string; name: string }) => ({
+          label: p.name,
+          description: p.id,
+          id: p.id,
+        }));
+
+        const selected = await notifications.quickPick(items, { title: 'Select Pattern to Ignore' });
+
+        if (!selected) {return;}
+
+        await client.sendRequest('drift/patterns/ignore', { id: selected.id });
+        await notifications.info(`Pattern "${selected.label}" ignored.`);
+      } else {
+        await client.sendRequest('drift/patterns/ignore', { id: patternId });
+        await notifications.info(`Pattern ignored.`);
+      }
+    },
+  });
+
+  // Create variant command
+  router.register({
+    id: DRIFT_COMMANDS.createVariant,
+    handler: async (ctx: CommandContext) => {
+      const client = connectionManager.getClient();
+      if (!client) {
+        throw new Error('Not connected to server');
+      }
+
+      const patternId = ctx.args[0] as string | undefined;
+      const violationId = ctx.args[1] as string | undefined;
+
+      if (!patternId) {
+        await notifications.warning('No pattern specified for variant creation.');
+        return;
+      }
+
+      // Get variant name from user
+      const name = await notifications.inputBox({
+        title: 'Create Variant',
+        prompt: 'Enter a name for this variant',
+        placeHolder: 'e.g., legacy-auth-pattern',
+      });
+
+      if (!name) {return;}
+
+      // Get variant description
+      const description = await notifications.inputBox({
+        title: 'Create Variant',
+        prompt: 'Enter a description (optional)',
+        placeHolder: 'e.g., Used in legacy authentication module',
+      });
+
+      await client.sendRequest('drift/patterns/createVariant', {
+        patternId,
+        violationId,
+        name,
+        description,
+      });
+
+      await notifications.info(`Variant "${name}" created.`);
+    },
+  });
+}

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

@@ -0,0 +1,107 @@
+/**
+ * Scan command handlers
+ * 
+ * Single responsibility: Handle scan-related commands.
+ */
+
+import * as vscode from 'vscode';
+
+import { DRIFT_COMMANDS } from '../command-definitions.js';
+
+import type { ConnectionManager } from '../../client/index.js';
+import type { EventBus } from '../../infrastructure/event-bus.js';
+import type { StateManager } from '../../state/index.js';
+import type { NotificationService } from '../../ui/notifications/notification-service.js';
+import type { CommandRouter, CommandContext } from '../command-router.js';
+
+
+/**
+ * Create scan command handlers
+ */
+export function createScanHandlers(
+  router: CommandRouter,
+  connectionManager: ConnectionManager,
+  stateManager: StateManager,
+  notifications: NotificationService,
+  eventBus: EventBus
+): void {
+  // Rescan workspace command
+  router.register({
+    id: DRIFT_COMMANDS.rescan,
+    showProgress: true,
+    progressTitle: 'Scanning workspace...',
+    handler: async (ctx: CommandContext) => {
+      const client = connectionManager.getClient();
+      if (!client) {
+        throw new Error('Not connected to server');
+      }
+
+      // Update state to scanning
+      stateManager.update(draft => {
+        draft.workspace.scanning = true;
+      });
+
+      eventBus.emit('scan:started', { files: 0 });
+
+      try {
+        ctx.progress?.report({ message: 'Analyzing patterns...' });
+
+        const result = await client.sendRequest<{
+          patterns: number;
+          violations: number;
+          duration: number;
+        }>('drift/rescan');
+
+        // Update state with results
+        stateManager.update(draft => {
+          draft.workspace.scanning = false;
+          draft.workspace.lastScanTime = Date.now();
+          draft.patterns.total = result.patterns;
+          draft.violations.total = result.violations;
+        });
+
+        eventBus.emit('scan:completed', {
+          duration: result.duration,
+          patterns: result.patterns,
+          violations: result.violations,
+        });
+
+        await notifications.info(
+          `Scan complete: ${result.patterns} patterns, ${result.violations} violations`
+        );
+      } catch (error) {
+        stateManager.update(draft => {
+          draft.workspace.scanning = false;
+        });
+        throw error;
+      }
+    },
+  });
+
+  // Scan current file command
+  router.register({
+    id: DRIFT_COMMANDS.scanFile,
+    handler: async (_ctx: CommandContext) => {
+      const editor = vscode.window.activeTextEditor;
+      if (!editor) {
+        await notifications.warning('No file is currently open.');
+        return;
+      }
+
+      const client = connectionManager.getClient();
+      if (!client) {
+        throw new Error('Not connected to server');
+      }
+
+      const uri = editor.document.uri.toString();
+
+      await notifications.withProgress('Scanning file...', async (progress) => {
+        progress.report({ message: editor.document.fileName });
+
+        await client.sendRequest('drift/scanFile', { uri });
+
+        await notifications.info('File scan complete.');
+      });
+    },
+  });
+}

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

@@ -0,0 +1,88 @@
+/**
+ * UI command handlers
+ * 
+ * Single responsibility: Handle UI-related commands.
+ */
+
+import * as vscode from 'vscode';
+
+import { DRIFT_COMMANDS } from '../command-definitions.js';
+
+import type { NotificationService } from '../../ui/notifications/notification-service.js';
+import type { CommandRouter, CommandContext } from '../command-router.js';
+
+/**
+ * Create UI command handlers
+ */
+export function createUIHandlers(
+  router: CommandRouter,
+  notifications: NotificationService
+): void {
+  // Open dashboard command
+  router.register({
+    id: DRIFT_COMMANDS.openDashboard,
+    handler: async (_ctx: CommandContext) => {
+      // Open the dashboard webview
+      await vscode.commands.executeCommand('drift.dashboard.focus');
+    },
+  });
+
+  // Open settings command
+  router.register({
+    id: DRIFT_COMMANDS.openSettings,
+    handler: async (_ctx: CommandContext) => {
+      // Open VS Code settings filtered to Drift
+      await vscode.commands.executeCommand(
+        'workbench.action.openSettings',
+        '@ext:drift.drift'
+      );
+    },
+  });
+
+  // Export patterns command
+  router.register({
+    id: DRIFT_COMMANDS.exportPatterns,
+    showProgress: true,
+    progressTitle: 'Exporting patterns...',
+    handler: async (_ctx: CommandContext) => {
+      // Show save dialog
+      const uri = await vscode.window.showSaveDialog({
+        defaultUri: vscode.Uri.file('drift-patterns.json'),
+        filters: {
+          'JSON': ['json'],
+          'All Files': ['*'],
+        },
+        title: 'Export Patterns',
+      });
+
+      if (!uri) {return;}
+
+      // TODO: Implement actual export via LSP
+      await notifications.info(`Patterns exported to ${uri.fsPath}`);
+    },
+  });
+
+  // Generate report command
+  router.register({
+    id: DRIFT_COMMANDS.generateReport,
+    showProgress: true,
+    progressTitle: 'Generating report...',
+    handler: async (_ctx: CommandContext) => {
+      // Show save dialog
+      const uri = await vscode.window.showSaveDialog({
+        defaultUri: vscode.Uri.file('drift-report.html'),
+        filters: {
+          'HTML': ['html'],
+          'Markdown': ['md'],
+          'JSON': ['json'],
+        },
+        title: 'Generate Report',
+      });
+
+      if (!uri) {return;}
+
+      // TODO: Implement actual report generation via LSP
+      await notifications.info(`Report generated at ${uri.fsPath}`);
+    },
+  });
+}

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

@@ -0,0 +1,97 @@
+/**
+ * Violation command handlers
+ * 
+ * Single responsibility: Handle violation-related commands.
+ */
+
+import * as vscode from 'vscode';
+
+import { DRIFT_COMMANDS } from '../command-definitions.js';
+
+import type { ConnectionManager } from '../../client/index.js';
+import type { NotificationService } from '../../ui/notifications/notification-service.js';
+import type { CommandRouter, CommandContext } from '../command-router.js';
+
+
+/**
+ * Create violation command handlers
+ */
+export function createViolationHandlers(
+  router: CommandRouter,
+  connectionManager: ConnectionManager,
+  notifications: NotificationService
+): void {
+  // Show violations command
+  router.register({
+    id: DRIFT_COMMANDS.showViolations,
+    handler: async (_ctx: CommandContext) => {
+      // Focus the violations tree view
+      await vscode.commands.executeCommand('drift.violations.focus');
+    },
+  });
+
+  // Ignore once command
+  router.register({
+    id: DRIFT_COMMANDS.ignoreOnce,
+    handler: async (ctx: CommandContext) => {
+      const client = connectionManager.getClient();
+      if (!client) {
+        throw new Error('Not connected to server');
+      }
+
+      const violationId = ctx.args[0] as string | undefined;
+      const uri = ctx.args[1] as string | undefined;
+      const line = ctx.args[2] as number | undefined;
+
+      if (!violationId || !uri || line === undefined) {
+        // Try to get from current editor position
+        const editor = vscode.window.activeTextEditor;
+        if (!editor) {
+          await notifications.warning('No violation selected.');
+          return;
+        }
+
+        const position = editor.selection.active;
+        const diagnostics = vscode.languages.getDiagnostics(editor.document.uri);
+        const driftDiagnostic = diagnostics.find(
+          d => d.source === 'drift' && d.range.contains(position)
+        );
+
+        if (!driftDiagnostic) {
+          await notifications.warning('No Drift violation at cursor position.');
+          return;
+        }
+
+        // Extract violation ID from diagnostic data
+        const data = (driftDiagnostic as any).data;
+        if (!data?.violationId) {
+          await notifications.warning('Cannot identify violation.');
+          return;
+        }
+
+        await client.sendRequest('drift/violations/ignoreOnce', {
+          violationId: data.violationId,
+          uri: editor.document.uri.toString(),
+          line: driftDiagnostic.range.start.line,
+        });
+      } else {
+        await client.sendRequest('drift/violations/ignoreOnce', {
+          violationId,
+          uri,
+          line,
+        });
+      }
+
+      await notifications.info('Violation ignored for this occurrence.');
+    },
+  });
+
+  // Quick fix command
+  router.register({
+    id: DRIFT_COMMANDS.quickFix,
+    handler: async (_ctx: CommandContext) => {
+      // Trigger VS Code's built-in quick fix
+      await vscode.commands.executeCommand('editor.action.quickFix');
+    },
+  });
+}

package/src/commands/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Commands module exports
+ */
+
+export { CommandRouter, createCommandRouter } from './command-router.js';
+export { CommandDefinitions, DRIFT_COMMANDS } from './command-definitions.js';
+export * from './handlers/index.js';

package/src/commands/middleware/connection-check-middleware.ts

@@ -0,0 +1,46 @@
+/**
+ * Connection check middleware
+ * 
+ * Single responsibility: Verify connection before command execution.
+ */
+
+import { DRIFT_COMMANDS, type DriftCommand } from '../command-definitions.js';
+
+import type { StateManager } from '../../state/index.js';
+import type { CommandMiddleware, CommandContext } from '../command-router.js';
+
+/**
+ * Commands that don't require connection
+ */
+const CONNECTION_EXEMPT_COMMANDS = new Set<DriftCommand>([
+  DRIFT_COMMANDS.reconnect,
+  DRIFT_COMMANDS.showStatus,
+  DRIFT_COMMANDS.showError,
+  DRIFT_COMMANDS.openSettings,
+  DRIFT_COMMANDS.openDashboard,
+]);
+
+/**
+ * Create connection check middleware
+ */
+export function createConnectionCheckMiddleware(
+  stateManager: StateManager
+): CommandMiddleware {
+  return async (ctx: CommandContext, next: () => Promise<void>): Promise<void> => {
+    // Skip check for exempt commands
+    if (CONNECTION_EXEMPT_COMMANDS.has(ctx.command)) {
+      await next();
+      return;
+    }
+
+    const state = stateManager.getState();
+    
+    if (state.connection.status !== 'connected') {
+      throw new Error(
+        'Drift server is not connected. Please wait for initialization or run "Drift: Reconnect".'
+      );
+    }
+
+    await next();
+  };
+}

package/src/commands/middleware/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Command middleware module exports
+ */
+
+export { createLoggingMiddleware } from './logging-middleware.js';
+export { createConnectionCheckMiddleware } from './connection-check-middleware.js';
+export { createTelemetryMiddleware } from './telemetry-middleware.js';

package/src/commands/middleware/logging-middleware.ts

@@ -0,0 +1,28 @@
+/**
+ * Logging middleware
+ * 
+ * Single responsibility: Log command execution.
+ */
+
+import type { Logger } from '../../infrastructure/index.js';
+import type { CommandMiddleware, CommandContext } from '../command-router.js';
+
+/**
+ * Create logging middleware
+ */
+export function createLoggingMiddleware(logger: Logger): CommandMiddleware {
+  return async (ctx: CommandContext, next: () => Promise<void>): Promise<void> => {
+    logger.debug(`Executing command: ${ctx.command}`, { args: ctx.args });
+
+    try {
+      await next();
+      
+      const duration = performance.now() - ctx.startTime;
+      logger.debug(`Command completed: ${ctx.command} (${duration.toFixed(2)}ms)`);
+    } catch (error) {
+      const duration = performance.now() - ctx.startTime;
+      logger.error(`Command failed: ${ctx.command} (${duration.toFixed(2)}ms)`, error);
+      throw error;
+    }
+  };
+}

package/src/commands/middleware/telemetry-middleware.ts

@@ -0,0 +1,46 @@
+/**
+ * Telemetry middleware
+ * 
+ * Single responsibility: Track command usage for analytics.
+ */
+
+import type { CommandMiddleware, CommandContext } from '../command-router.js';
+
+/**
+ * Telemetry tracker interface
+ */
+export interface TelemetryTracker {
+  trackCommand(data: {
+    command: string;
+    duration: number;
+    success: boolean;
+    error?: string;
+  }): void;
+}
+
+/**
+ * Create telemetry middleware
+ */
+export function createTelemetryMiddleware(
+  tracker: TelemetryTracker
+): CommandMiddleware {
+  return async (ctx: CommandContext, next: () => Promise<void>): Promise<void> => {
+    try {
+      await next();
+
+      tracker.trackCommand({
+        command: ctx.command,
+        duration: performance.now() - ctx.startTime,
+        success: true,
+      });
+    } catch (error) {
+      tracker.trackCommand({
+        command: ctx.command,
+        duration: performance.now() - ctx.startTime,
+        success: false,
+        error: error instanceof Error ? error.name : 'UnknownError',
+      });
+      throw error;
+    }
+  };
+}