driftdetect-vscode 0.8.2

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

@@ -0,0 +1,167 @@
+/**
+ * NotificationService - User notification management
+ * 
+ * Single responsibility: Display notifications to users.
+ */
+
+import * as vscode from 'vscode';
+
+import type { Logger } from '../../infrastructure/index.js';
+
+/**
+ * Notification action
+ */
+export interface NotificationAction {
+  title: string;
+  command?: string;
+  args?: unknown[];
+  callback?: () => void | Promise<void>;
+}
+
+/**
+ * Notification options
+ */
+export interface NotificationOptions {
+  modal?: boolean;
+  detail?: string;
+}
+
+/**
+ * Notification service for user messages
+ */
+export class NotificationService {
+  constructor(private readonly logger: Logger) {}
+
+  /**
+   * Show an information message
+   */
+  async info(
+    message: string,
+    actions: NotificationAction[] = [],
+    options: NotificationOptions = {}
+  ): Promise<string | undefined> {
+    return this.show('info', message, actions, options);
+  }
+
+  /**
+   * Show a warning message
+   */
+  async warning(
+    message: string,
+    actions: NotificationAction[] = [],
+    options: NotificationOptions = {}
+  ): Promise<string | undefined> {
+    return this.show('warning', message, actions, options);
+  }
+
+  /**
+   * Show an error message
+   */
+  async error(
+    message: string,
+    actions: NotificationAction[] = [],
+    options: NotificationOptions = {}
+  ): Promise<string | undefined> {
+    this.logger.error(message);
+    return this.show('error', message, actions, options);
+  }
+
+  /**
+   * Show a progress notification
+   */
+  async withProgress<T>(
+    title: string,
+    task: (
+      progress: vscode.Progress<{ message?: string; increment?: number }>,
+      token: vscode.CancellationToken
+    ) => Promise<T>,
+    options: { cancellable?: boolean; location?: vscode.ProgressLocation } = {}
+  ): Promise<T> {
+    return vscode.window.withProgress(
+      {
+        location: options.location ?? vscode.ProgressLocation.Notification,
+        title: `Drift: ${title}`,
+        cancellable: options.cancellable ?? false,
+      },
+      task
+    );
+  }
+
+  /**
+   * Show a quick pick
+   */
+  async quickPick<T extends vscode.QuickPickItem>(
+    items: T[],
+    options: vscode.QuickPickOptions = {}
+  ): Promise<T | undefined> {
+    const pickOptions: vscode.QuickPickOptions = {
+      ...options,
+    };
+    if (options.title) {
+      pickOptions.title = `Drift: ${options.title}`;
+    }
+    return vscode.window.showQuickPick(items, pickOptions);
+  }
+
+  /**
+   * Show an input box
+   */
+  async inputBox(options: vscode.InputBoxOptions = {}): Promise<string | undefined> {
+    const inputOptions: vscode.InputBoxOptions = {
+      ...options,
+    };
+    if (options.title) {
+      inputOptions.title = `Drift: ${options.title}`;
+    }
+    return vscode.window.showInputBox(inputOptions);
+  }
+
+  private async show(
+    type: 'info' | 'warning' | 'error',
+    message: string,
+    actions: NotificationAction[],
+    options: NotificationOptions
+  ): Promise<string | undefined> {
+    const actionTitles = actions.map(a => a.title);
+    
+    const showFn = {
+      info: vscode.window.showInformationMessage,
+      warning: vscode.window.showWarningMessage,
+      error: vscode.window.showErrorMessage,
+    }[type];
+
+    const messageOptions: vscode.MessageOptions = {};
+    if (options.modal !== undefined) {
+      messageOptions.modal = options.modal;
+    }
+    if (options.detail !== undefined) {
+      messageOptions.detail = options.detail;
+    }
+
+    const selected = await showFn(
+      `Drift: ${message}`,
+      messageOptions,
+      ...actionTitles
+    );
+
+    if (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 || []));
+        }
+      }
+    }
+
+    return selected;
+  }
+}
+
+/**
+ * Factory function for creating notification service
+ */
+export function createNotificationService(logger: Logger): NotificationService {
+  return new NotificationService(logger);
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Status bar module exports
+ */
+
+export { StatusBarController, createStatusBar } from './status-bar-controller.js';
+export { StatusBarModes, getStatusBarMode } from './status-bar-modes.js';

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

@@ -0,0 +1,135 @@
+/**
+ * StatusBarController - Status bar management
+ * 
+ * Single responsibility: Display extension status in VS Code status bar.
+ */
+
+import * as vscode from 'vscode';
+
+import { getStatusBarMode } from './status-bar-modes.js';
+import { selectStatusBarData } from '../../state/selectors.js';
+
+import type { StateManager } from '../../state/index.js';
+
+/**
+ * Status bar controller
+ */
+export class StatusBarController implements vscode.Disposable {
+  private readonly item: vscode.StatusBarItem;
+  private readonly disposables: vscode.Disposable[] = [];
+
+  constructor(private readonly stateManager: StateManager) {
+    this.item = vscode.window.createStatusBarItem(
+      vscode.StatusBarAlignment.Right,
+      100
+    );
+
+    this.setupSubscriptions();
+    this.updateDisplay();
+    this.item.show();
+  }
+
+  /**
+   * Show the status bar item
+   */
+  show(): void {
+    this.item.show();
+  }
+
+  /**
+   * Hide the status bar item
+   */
+  hide(): void {
+    this.item.hide();
+  }
+
+  /**
+   * Dispose resources
+   */
+  dispose(): void {
+    this.item.dispose();
+    for (const d of this.disposables) {
+      d.dispose();
+    }
+  }
+
+  private setupSubscriptions(): void {
+    // Subscribe to relevant state changes
+    this.disposables.push(
+      this.stateManager.subscribe(selectStatusBarData, () => {
+        this.updateDisplay();
+      })
+    );
+  }
+
+  private updateDisplay(): void {
+    const state = this.stateManager.getState();
+    const { status, violations, scanning } = {
+      status: state.connection.status,
+      violations: state.violations.total,
+      scanning: state.workspace.scanning,
+    };
+
+    const mode = getStatusBarMode(status, violations, scanning);
+
+    this.item.text = `${mode.icon} ${mode.text}`;
+    this.item.tooltip = this.buildTooltip(mode.tooltip, state);
+    this.item.backgroundColor = mode.backgroundColor;
+    this.item.command = mode.command;
+  }
+
+  private buildTooltip(baseTooltip: string, state: ReturnType<StateManager['getState']>): vscode.MarkdownString {
+    const md = new vscode.MarkdownString();
+    md.isTrusted = true;
+    md.supportThemeIcons = true;
+
+    md.appendMarkdown(`### $(drift-logo) Drift\n\n`);
+    md.appendMarkdown(`${baseTooltip}\n\n`);
+
+    // 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`);
+
+      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(`\n---\n\n`);
+      md.appendMarkdown(`[View Violations](command:drift.showViolations) | `);
+      md.appendMarkdown(`[View Patterns](command:drift.showPatterns) | `);
+      md.appendMarkdown(`[Rescan](command:drift.rescan)\n`);
+    }
+
+    return md;
+  }
+
+  private getSeverityIcon(severity: string): string {
+    switch (severity) {
+      case 'error':
+        return '$(error)';
+      case 'warning':
+        return '$(warning)';
+      case 'info':
+        return '$(info)';
+      case 'hint':
+        return '$(lightbulb)';
+      default:
+        return '$(circle)';
+    }
+  }
+}
+
+/**
+ * Factory function for creating status bar controller
+ */
+export function createStatusBar(stateManager: StateManager): StatusBarController {
+  return new StatusBarController(stateManager);
+}

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

@@ -0,0 +1,119 @@
+/**
+ * Status bar display modes
+ * 
+ * Single responsibility: Define status bar visual states.
+ */
+
+import * as vscode from 'vscode';
+
+import type { ConnectionState } from '../../types/index.js';
+
+/**
+ * Status bar mode configuration
+ */
+export interface StatusBarMode {
+  icon: string;
+  text: string;
+  tooltip: string;
+  backgroundColor?: vscode.ThemeColor;
+  command?: string;
+}
+
+/**
+ * Status bar modes for different states
+ */
+export const StatusBarModes: Record<string, StatusBarMode> = {
+  disconnected: {
+    icon: '$(circle-slash)',
+    text: 'Drift: Disconnected',
+    tooltip: 'Drift is not connected. Click to reconnect.',
+    backgroundColor: new vscode.ThemeColor('statusBarItem.errorBackground'),
+    command: 'drift.reconnect',
+  },
+  connecting: {
+    icon: '$(sync~spin)',
+    text: 'Drift: Connecting...',
+    tooltip: 'Connecting to Drift server...',
+  },
+  connected: {
+    icon: '$(check)',
+    text: 'Drift: Ready',
+    tooltip: 'Drift is connected and ready.',
+    command: 'drift.showStatus',
+  },
+  reconnecting: {
+    icon: '$(sync~spin)',
+    text: 'Drift: Reconnecting...',
+    tooltip: 'Reconnecting to Drift server...',
+  },
+  error: {
+    icon: '$(error)',
+    text: 'Drift: Error',
+    tooltip: 'Drift encountered an error. Click for details.',
+    backgroundColor: new vscode.ThemeColor('statusBarItem.errorBackground'),
+    command: 'drift.showError',
+  },
+  failed: {
+    icon: '$(error)',
+    text: 'Drift: Failed',
+    tooltip: 'Drift failed to connect. Click to retry.',
+    backgroundColor: new vscode.ThemeColor('statusBarItem.errorBackground'),
+    command: 'drift.reconnect',
+  },
+  scanning: {
+    icon: '$(sync~spin)',
+    text: 'Drift: Scanning...',
+    tooltip: 'Scanning workspace for patterns...',
+  },
+  healthy: {
+    icon: '$(pass)',
+    text: 'Drift',
+    tooltip: 'No violations found.',
+    command: 'drift.showStatus',
+  },
+  warning: {
+    icon: '$(warning)',
+    text: 'Drift',
+    tooltip: 'Violations found. Click to view.',
+    backgroundColor: new vscode.ThemeColor('statusBarItem.warningBackground'),
+    command: 'drift.showViolations',
+  },
+};
+
+/**
+ * Get status bar mode based on state
+ */
+export function getStatusBarMode(
+  connectionState: ConnectionState,
+  violations: number,
+  scanning: boolean
+): StatusBarMode {
+  // Connection states take priority
+  if (connectionState !== 'connected') {
+    return StatusBarModes[connectionState] ?? StatusBarModes['disconnected']!;
+  }
+
+  // Scanning state
+  if (scanning) {
+    return StatusBarModes['scanning']!;
+  }
+
+  // Violation-based states
+  if (violations > 0) {
+    const warningMode = StatusBarModes['warning']!;
+    const result: StatusBarMode = {
+      icon: warningMode.icon,
+      text: `Drift: ${violations}`,
+      tooltip: `${violations} violation${violations === 1 ? '' : 's'} found. Click to view.`,
+    };
+    if (warningMode.backgroundColor) {
+      result.backgroundColor = warningMode.backgroundColor;
+    }
+    if (warningMode.command) {
+      result.command = warningMode.command;
+    }
+    return result;
+  }
+
+  return StatusBarModes['healthy']!;
+}

package/src/views/base-tree-provider.ts

@@ -0,0 +1,127 @@
+/**
+ * BaseTreeProvider - Abstract base for tree view providers
+ * 
+ * Single responsibility: Provide common tree view functionality.
+ */
+
+import * as vscode from 'vscode';
+
+import type { LanguageClient } from 'vscode-languageclient/node';
+
+/**
+ * Base tree item with common properties
+ */
+export interface BaseTreeItem extends vscode.TreeItem {
+  contextValue: string;
+}
+
+/**
+ * Cache entry with expiry
+ */
+interface CacheEntry<T> {
+  data: T;
+  expiry: number;
+}
+
+/**
+ * Abstract base class for tree providers
+ */
+export abstract class BaseTreeProvider<T extends BaseTreeItem>
+  implements vscode.TreeDataProvider<T>, vscode.Disposable
+{
+  protected readonly cache = new Map<string, CacheEntry<T[]>>();
+  protected readonly disposables: vscode.Disposable[] = [];
+  protected readonly cacheTTL = 30000; // 30 seconds
+
+  protected readonly _onDidChangeTreeData = new vscode.EventEmitter<T | undefined>();
+  readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
+
+  constructor(protected readonly client: LanguageClient | null) {}
+
+  /**
+   * Refresh the tree view
+   */
+  refresh(item?: T): void {
+    if (item) {
+      this.invalidateCache(this.getCacheKey(item));
+    } else {
+      this.invalidateAllCache();
+    }
+    this._onDidChangeTreeData.fire(item);
+  }
+
+  /**
+   * Get tree item representation
+   */
+  getTreeItem(element: T): vscode.TreeItem {
+    return element;
+  }
+
+  /**
+   * Get children of an element
+   */
+  abstract getChildren(element?: T): Promise<T[]>;
+
+  /**
+   * Dispose resources
+   */
+  dispose(): void {
+    this._onDidChangeTreeData.dispose();
+    this.cache.clear();
+    for (const d of this.disposables) {
+      d.dispose();
+    }
+  }
+
+  /**
+   * Get cache key for an item
+   */
+  protected getCacheKey(item?: T): string {
+    return item?.id?.toString() ?? 'root';
+  }
+
+  /**
+   * Get cached data if valid
+   */
+  protected getCached(key: string): T[] | undefined {
+    const entry = this.cache.get(key);
+    if (entry && entry.expiry > Date.now()) {
+      return entry.data;
+    }
+    return undefined;
+  }
+
+  /**
+   * Set cache data
+   */
+  protected setCache(key: string, data: T[]): void {
+    this.cache.set(key, {
+      data,
+      expiry: Date.now() + this.cacheTTL,
+    });
+  }
+
+  /**
+   * Invalidate specific cache entry
+   */
+  protected invalidateCache(key: string): void {
+    this.cache.delete(key);
+  }
+
+  /**
+   * Invalidate all cache entries
+   */
+  protected invalidateAllCache(): void {
+    this.cache.clear();
+  }
+
+  /**
+   * Send request to LSP server
+   */
+  protected async sendRequest<R>(method: string, params?: unknown): Promise<R> {
+    if (!this.client) {
+      throw new Error('Not connected to server');
+    }
+    return this.client.sendRequest<R>(method, params);
+  }
+}