driftdetect-vscode 0.8.2

package/src/commands/command-definitions.ts

@@ -0,0 +1,243 @@
+/**
+ * Command definitions
+ * 
+ * Single responsibility: Define all extension commands.
+ */
+
+/**
+ * All Drift command IDs
+ */
+export const DRIFT_COMMANDS = {
+  // Connection commands
+  reconnect: 'drift.reconnect',
+  showStatus: 'drift.showStatus',
+  showError: 'drift.showError',
+
+  // Scan commands
+  rescan: 'drift.rescan',
+  scanFile: 'drift.scanFile',
+
+  // Pattern commands
+  showPatterns: 'drift.showPatterns',
+  approvePattern: 'drift.approvePattern',
+  ignorePattern: 'drift.ignorePattern',
+  createVariant: 'drift.createVariant',
+
+  // Violation commands
+  showViolations: 'drift.showViolations',
+  ignoreOnce: 'drift.ignoreOnce',
+  quickFix: 'drift.quickFix',
+
+  // AI commands
+  explainWithAI: 'drift.explainWithAI',
+  fixWithAI: 'drift.fixWithAI',
+
+  // UI commands
+  openDashboard: 'drift.openDashboard',
+  openSettings: 'drift.openSettings',
+
+  // Export commands
+  exportPatterns: 'drift.exportPatterns',
+  generateReport: 'drift.generateReport',
+
+  // Constants commands
+  showConstants: 'drift.showConstants',
+  showConstantsByCategory: 'drift.showConstantsByCategory',
+  showConstantsByLanguage: 'drift.showConstantsByLanguage',
+  showConstantIssues: 'drift.showConstantIssues',
+  goToConstant: 'drift.goToConstant',
+  findConstantUsages: 'drift.findConstantUsages',
+} as const;
+
+/**
+ * Command type
+ */
+export type DriftCommand = typeof DRIFT_COMMANDS[keyof typeof DRIFT_COMMANDS];
+
+/**
+ * Command metadata
+ */
+export interface CommandDefinition {
+  id: DriftCommand;
+  title: string;
+  category: 'Drift';
+  icon?: string;
+  enablement?: string;
+}
+
+/**
+ * All command definitions
+ */
+export const CommandDefinitions: CommandDefinition[] = [
+  // Connection
+  {
+    id: DRIFT_COMMANDS.reconnect,
+    title: 'Reconnect to Server',
+    category: 'Drift',
+    icon: '$(refresh)',
+  },
+  {
+    id: DRIFT_COMMANDS.showStatus,
+    title: 'Show Status',
+    category: 'Drift',
+    icon: '$(info)',
+  },
+  {
+    id: DRIFT_COMMANDS.showError,
+    title: 'Show Error Details',
+    category: 'Drift',
+    icon: '$(error)',
+  },
+
+  // Scan
+  {
+    id: DRIFT_COMMANDS.rescan,
+    title: 'Rescan Workspace',
+    category: 'Drift',
+    icon: '$(sync)',
+    enablement: 'drift.connected',
+  },
+  {
+    id: DRIFT_COMMANDS.scanFile,
+    title: 'Scan Current File',
+    category: 'Drift',
+    icon: '$(file-code)',
+    enablement: 'drift.connected && editorIsOpen',
+  },
+
+  // Patterns
+  {
+    id: DRIFT_COMMANDS.showPatterns,
+    title: 'Show All Patterns',
+    category: 'Drift',
+    icon: '$(list-tree)',
+    enablement: 'drift.connected',
+  },
+  {
+    id: DRIFT_COMMANDS.approvePattern,
+    title: 'Approve Pattern',
+    category: 'Drift',
+    icon: '$(check)',
+    enablement: 'drift.connected',
+  },
+  {
+    id: DRIFT_COMMANDS.ignorePattern,
+    title: 'Ignore Pattern',
+    category: 'Drift',
+    icon: '$(x)',
+    enablement: 'drift.connected',
+  },
+  {
+    id: DRIFT_COMMANDS.createVariant,
+    title: 'Create Variant',
+    category: 'Drift',
+    icon: '$(git-branch)',
+    enablement: 'drift.connected',
+  },
+
+  // Violations
+  {
+    id: DRIFT_COMMANDS.showViolations,
+    title: 'Show All Violations',
+    category: 'Drift',
+    icon: '$(warning)',
+    enablement: 'drift.connected',
+  },
+  {
+    id: DRIFT_COMMANDS.ignoreOnce,
+    title: 'Ignore This Occurrence',
+    category: 'Drift',
+    enablement: 'drift.connected',
+  },
+  {
+    id: DRIFT_COMMANDS.quickFix,
+    title: 'Apply Quick Fix',
+    category: 'Drift',
+    icon: '$(lightbulb)',
+    enablement: 'drift.connected',
+  },
+
+  // AI
+  {
+    id: DRIFT_COMMANDS.explainWithAI,
+    title: 'Explain with AI',
+    category: 'Drift',
+    icon: '$(sparkle)',
+    enablement: 'drift.connected && drift.aiEnabled',
+  },
+  {
+    id: DRIFT_COMMANDS.fixWithAI,
+    title: 'Fix with AI',
+    category: 'Drift',
+    icon: '$(wand)',
+    enablement: 'drift.connected && drift.aiEnabled',
+  },
+
+  // UI
+  {
+    id: DRIFT_COMMANDS.openDashboard,
+    title: 'Open Dashboard',
+    category: 'Drift',
+    icon: '$(dashboard)',
+  },
+  {
+    id: DRIFT_COMMANDS.openSettings,
+    title: 'Open Settings',
+    category: 'Drift',
+    icon: '$(gear)',
+  },
+
+  // Export
+  {
+    id: DRIFT_COMMANDS.exportPatterns,
+    title: 'Export Patterns',
+    category: 'Drift',
+    enablement: 'drift.connected',
+  },
+  {
+    id: DRIFT_COMMANDS.generateReport,
+    title: 'Generate Report',
+    category: 'Drift',
+    enablement: 'drift.connected',
+  },
+
+  // Constants
+  {
+    id: DRIFT_COMMANDS.showConstants,
+    title: 'Show Constants',
+    category: 'Drift',
+    icon: '$(symbol-constant)',
+    enablement: 'drift.connected',
+  },
+  {
+    id: DRIFT_COMMANDS.showConstantsByCategory,
+    title: 'View Constants by Category',
+    category: 'Drift',
+    enablement: 'drift.connected',
+  },
+  {
+    id: DRIFT_COMMANDS.showConstantsByLanguage,
+    title: 'View Constants by Language',
+    category: 'Drift',
+    enablement: 'drift.connected',
+  },
+  {
+    id: DRIFT_COMMANDS.showConstantIssues,
+    title: 'View Constant Issues',
+    category: 'Drift',
+    icon: '$(warning)',
+    enablement: 'drift.connected',
+  },
+  {
+    id: DRIFT_COMMANDS.goToConstant,
+    title: 'Go to Constant Definition',
+    category: 'Drift',
+    enablement: 'drift.connected',
+  },
+  {
+    id: DRIFT_COMMANDS.findConstantUsages,
+    title: 'Find Constant Usages',
+    category: 'Drift',
+    enablement: 'drift.connected',
+  },
+];

package/src/commands/command-router.ts

@@ -0,0 +1,194 @@
+/**
+ * CommandRouter - Centralized command handling with middleware
+ * 
+ * Single responsibility: Route commands through middleware chain.
+ */
+
+import * as vscode from 'vscode';
+
+import type { DriftCommand } from './command-definitions.js';
+import type { Logger } from '../infrastructure/index.js';
+import type { StateManager } from '../state/index.js';
+
+/**
+ * Command context passed to handlers
+ */
+export interface CommandContext {
+  command: DriftCommand;
+  args: unknown[];
+  startTime: number;
+  progress?: vscode.Progress<{ message?: string; increment?: number }>;
+  cancellationToken?: vscode.CancellationToken;
+}
+
+/**
+ * Command handler function
+ */
+export type CommandHandler = (ctx: CommandContext) => Promise<void>;
+
+/**
+ * Command middleware function
+ */
+export type CommandMiddleware = (
+  ctx: CommandContext,
+  next: () => Promise<void>
+) => Promise<void>;
+
+/**
+ * Command registration
+ */
+interface CommandRegistration {
+  id: DriftCommand;
+  handler: CommandHandler;
+  showProgress?: boolean;
+  progressTitle?: string;
+}
+
+/**
+ * Command router with middleware support
+ */
+export class CommandRouter implements vscode.Disposable {
+  private readonly handlers = new Map<DriftCommand, CommandRegistration>();
+  private readonly middleware: CommandMiddleware[] = [];
+  private readonly disposables: vscode.Disposable[] = [];
+
+  constructor(
+    private readonly context: vscode.ExtensionContext,
+    private readonly logger: Logger,
+    _stateManager: StateManager // Available for future use
+  ) {}
+
+  /**
+   * Add middleware to the chain
+   */
+  use(middleware: CommandMiddleware): this {
+    this.middleware.push(middleware);
+    return this;
+  }
+
+  /**
+   * Register a command handler
+   */
+  register(registration: CommandRegistration): vscode.Disposable {
+    this.handlers.set(registration.id, registration);
+
+    const disposable = vscode.commands.registerCommand(
+      registration.id,
+      async (...args: unknown[]) => {
+        await this.execute(registration, args);
+      }
+    );
+
+    this.disposables.push(disposable);
+    this.context.subscriptions.push(disposable);
+
+    return disposable;
+  }
+
+  /**
+   * Register multiple command handlers
+   */
+  registerAll(registrations: CommandRegistration[]): void {
+    for (const reg of registrations) {
+      this.register(reg);
+    }
+  }
+
+  /**
+   * Execute a command programmatically
+   */
+  async executeCommand(command: DriftCommand, ...args: unknown[]): Promise<void> {
+    await vscode.commands.executeCommand(command, ...args);
+  }
+
+  /**
+   * Dispose all registered commands
+   */
+  dispose(): void {
+    for (const d of this.disposables) {
+      d.dispose();
+    }
+    this.handlers.clear();
+    this.middleware.length = 0;
+  }
+
+  private async execute(registration: CommandRegistration, args: unknown[]): Promise<void> {
+    const ctx: CommandContext = {
+      command: registration.id,
+      args,
+      startTime: performance.now(),
+    };
+
+    try {
+      if (registration.showProgress) {
+        await this.executeWithProgress(registration, ctx);
+      } else {
+        await this.executeWithMiddleware(registration.handler, ctx);
+      }
+    } catch (error) {
+      this.handleError(registration.id, error);
+    }
+  }
+
+  private async executeWithProgress(
+    registration: CommandRegistration,
+    ctx: CommandContext
+  ): Promise<void> {
+    await vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: registration.progressTitle || `Drift: ${registration.id}`,
+        cancellable: true,
+      },
+      async (progress, token) => {
+        ctx.progress = progress;
+        ctx.cancellationToken = token;
+        await this.executeWithMiddleware(registration.handler, ctx);
+      }
+    );
+  }
+
+  private async executeWithMiddleware(
+    handler: CommandHandler,
+    ctx: CommandContext
+  ): Promise<void> {
+    let index = 0;
+
+    const next = async (): Promise<void> => {
+      if (index < this.middleware.length) {
+        const mw = this.middleware[index++]!;
+        await mw(ctx, next);
+      } else {
+        await handler(ctx);
+      }
+    };
+
+    await next();
+  }
+
+  private handleError(command: DriftCommand, error: unknown): void {
+    const message = error instanceof Error ? error.message : String(error);
+    this.logger.error(`Command ${command} failed:`, message);
+
+    vscode.window
+      .showErrorMessage(`Drift: ${message}`, 'Retry', 'Show Logs')
+      .then((action) => {
+        if (action === 'Retry') {
+          vscode.commands.executeCommand(command);
+        } else if (action === 'Show Logs') {
+          vscode.commands.executeCommand('drift.showLogs');
+        }
+      });
+  }
+}
+
+/**
+ * Factory function for creating command router
+ */
+export function createCommandRouter(
+  context: vscode.ExtensionContext,
+  logger: Logger,
+  stateManager: StateManager
+): CommandRouter {
+  return new CommandRouter(context, logger, stateManager);
+}

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

@@ -0,0 +1,74 @@
+/**
+ * Connection command handlers
+ * 
+ * Single responsibility: Handle connection-related commands.
+ */
+
+import { DRIFT_COMMANDS } from '../command-definitions.js';
+
+import type { ConnectionManager } from '../../client/index.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 connection command handlers
+ */
+export function createConnectionHandlers(
+  router: CommandRouter,
+  connectionManager: ConnectionManager,
+  stateManager: StateManager,
+  notifications: NotificationService
+): void {
+  // Reconnect command
+  router.register({
+    id: DRIFT_COMMANDS.reconnect,
+    handler: async (_ctx: CommandContext) => {
+      await notifications.withProgress('Reconnecting...', async (progress) => {
+        progress.report({ message: 'Disconnecting...' });
+        await connectionManager.disconnect();
+        
+        progress.report({ message: 'Connecting...' });
+        await connectionManager.connect();
+      });
+    },
+  });
+
+  // Show status command
+  router.register({
+    id: DRIFT_COMMANDS.showStatus,
+    handler: async (_ctx: CommandContext) => {
+      const state = stateManager.getState();
+      const { connection, patterns, violations, workspace } = state;
+
+      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'}`,
+      ];
+
+      await notifications.info(items.join('\n'), [], { detail: 'Drift Status' });
+    },
+  });
+
+  // Show error command
+  router.register({
+    id: DRIFT_COMMANDS.showError,
+    handler: async (_ctx: CommandContext) => {
+      const state = stateManager.getState();
+      const error = state.connection.lastError;
+
+      if (error) {
+        await notifications.error(error, [
+          { title: 'Retry', command: DRIFT_COMMANDS.reconnect },
+          { title: 'Show Logs', command: 'drift.showLogs' },
+        ]);
+      } else {
+        await notifications.info('No errors to display.');
+      }
+    },
+  });
+}

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

@@ -0,0 +1,99 @@
+/**
+ * Constants command handlers
+ *
+ * Handlers for constants-related commands.
+ */
+
+import * as vscode from 'vscode';
+
+import type { ConstantsTreeProvider } from '../../views/constants-tree-provider.js';
+
+/**
+ * Create constants command handlers
+ */
+export function createConstantsHandlers(
+  constantsProvider: ConstantsTreeProvider
+): Record<string, (...args: unknown[]) => Promise<void>> {
+  return {
+    /**
+     * Show constants view by category
+     */
+    'drift.showConstantsByCategory': async () => {
+      constantsProvider.setViewMode('category');
+      await vscode.commands.executeCommand('drift.constantsView.focus');
+    },
+
+    /**
+     * Show constants view by language
+     */
+    'drift.showConstantsByLanguage': async () => {
+      constantsProvider.setViewMode('language');
+      await vscode.commands.executeCommand('drift.constantsView.focus');
+    },
+
+    /**
+     * Show constant issues
+     */
+    'drift.showConstantIssues': async () => {
+      constantsProvider.setViewMode('issues');
+      await vscode.commands.executeCommand('drift.constantsView.focus');
+    },
+
+    /**
+     * Go to constant definition
+     */
+    'drift.goToConstant': async (file: unknown, line: unknown) => {
+      if (typeof file !== 'string' || typeof line !== 'number') {
+        return;
+      }
+
+      try {
+        const uri = vscode.Uri.file(file);
+        const document = await vscode.workspace.openTextDocument(uri);
+        const editor = await vscode.window.showTextDocument(document);
+
+        const position = new vscode.Position(Math.max(0, line - 1), 0);
+        editor.selection = new vscode.Selection(position, position);
+        editor.revealRange(
+          new vscode.Range(position, position),
+          vscode.TextEditorRevealType.InCenter
+        );
+      } catch (error) {
+        vscode.window.showErrorMessage(`Failed to open file: ${file}`);
+      }
+    },
+
+    /**
+     * Find constant usages
+     */
+    'drift.findConstantUsages': async (constantName: unknown) => {
+      if (typeof constantName !== 'string') {
+        // 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) {
+          return;
+        }
+        constantName = input;
+      }
+
+      // Use VSCode's built-in search
+      await vscode.commands.executeCommand('workbench.action.findInFiles', {
+        query: constantName,
+        isRegex: false,
+        isCaseSensitive: true,
+        matchWholeWord: true,
+      });
+    },
+
+    /**
+     * Show constants overview
+     */
+    'drift.showConstants': async () => {
+      constantsProvider.setViewMode('category');
+      await vscode.commands.executeCommand('drift.constantsView.focus');
+    },
+  };
+}

package/src/commands/handlers/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Command handlers module exports
+ */
+
+export { createConnectionHandlers } from './connection-handlers.js';
+export { createScanHandlers } from './scan-handlers.js';
+export { createPatternHandlers } from './pattern-handlers.js';
+export { createViolationHandlers } from './violation-handlers.js';
+export { createUIHandlers } from './ui-handlers.js';
+export { createConstantsHandlers } from './constants-handlers.js';