driftdetect-vscode 0.8.2

package/src/types/extension-types.ts

@@ -0,0 +1,58 @@
+/**
+ * Extension-level type definitions
+ */
+
+import type * as vscode from 'vscode';
+
+/**
+ * Extension activation phases for progressive loading
+ */
+export type ActivationPhase = 'immediate' | 'deferred' | 'lazy';
+
+/**
+ * Connection states for LSP client
+ */
+export type ConnectionState = 
+  | 'disconnected'
+  | 'connecting'
+  | 'connected'
+  | 'reconnecting'
+  | 'error'
+  | 'failed';
+
+/**
+ * Severity levels matching LSP
+ */
+export type Severity = 'error' | 'warning' | 'info' | 'hint';
+
+/**
+ * Pattern status
+ */
+export type PatternStatus = 'discovered' | 'approved' | 'ignored';
+
+/**
+ * Logger interface for dependency injection
+ */
+export interface Logger {
+  error(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  debug(message: string, ...args: unknown[]): void;
+}
+
+/**
+ * Disposable resource manager
+ */
+export interface DisposableManager {
+  add(disposable: vscode.Disposable): void;
+  dispose(): void;
+}
+
+/**
+ * Service locator for dependency injection
+ */
+export interface ServiceContainer {
+  get<T>(key: string): T;
+  register<T>(key: string, instance: T): void;
+  has(key: string): boolean;
+}

package/src/types/index.ts

@@ -0,0 +1,12 @@
+/**
+ * @drift/vscode - Type definitions
+ * 
+ * Central type exports for the VS Code extension.
+ * All types are defined in domain-specific files and re-exported here.
+ */
+
+export * from './extension-types.js';
+export * from './state-types.js';
+export * from './config-types.js';
+export * from './lsp-types.js';
+export * from './vscode-types.js';

package/src/types/lsp-types.ts

@@ -0,0 +1,77 @@
+/**
+ * LSP-related type definitions
+ */
+
+import type { Severity, PatternStatus } from './extension-types.js';
+
+/**
+ * Pattern data from LSP
+ */
+export interface PatternData {
+  id: string;
+  name: string;
+  category: string;
+  confidence: number;
+  status: PatternStatus;
+  locationCount: number;
+  description?: string;
+}
+
+/**
+ * Violation data from LSP
+ */
+export interface ViolationData {
+  id: string;
+  patternId: string;
+  severity: Severity;
+  file: string;
+  range: {
+    start: { line: number; character: number };
+    end: { line: number; character: number };
+  };
+  message: string;
+  hasQuickFix: boolean;
+  aiExplainAvailable: boolean;
+  aiFixAvailable: boolean;
+}
+
+/**
+ * Category summary from LSP
+ */
+export interface CategoryData {
+  name: string;
+  count: number;
+  approvedCount: number;
+  violationCount: number;
+}
+
+/**
+ * File pattern data from LSP
+ */
+export interface FilePatternData {
+  path: string;
+  patternCount: number;
+  violationCount: number;
+  categories: string[];
+}
+
+/**
+ * LSP health check response
+ */
+export interface HealthCheckResponse {
+  status: 'healthy' | 'degraded' | 'unhealthy';
+  version: string;
+  uptime: number;
+}
+
+/**
+ * LSP request types
+ */
+export type LSPRequestType =
+  | 'drift/health'
+  | 'drift/patterns/list'
+  | 'drift/patterns/get'
+  | 'drift/patterns/categories'
+  | 'drift/violations/list'
+  | 'drift/files/list'
+  | 'drift/rescan';

package/src/types/state-types.ts

@@ -0,0 +1,92 @@
+/**
+ * State management type definitions
+ */
+
+import type { ConnectionState, Severity, PatternStatus } from './extension-types.js';
+
+/**
+ * Connection state slice
+ */
+export interface ConnectionStateSlice {
+  status: ConnectionState;
+  serverVersion: string | null;
+  lastError: string | null;
+  restartCount: number;
+}
+
+/**
+ * Workspace state slice
+ */
+export interface WorkspaceStateSlice {
+  initialized: boolean;
+  projectRoot: string | null;
+  configPath: string | null;
+  lastScanTime: number | null;
+  scanning: boolean;
+}
+
+/**
+ * Pattern summary state slice
+ */
+export interface PatternStateSlice {
+  total: number;
+  byCategory: Record<string, number>;
+  byStatus: Record<PatternStatus, number>;
+  lastUpdated: number | null;
+}
+
+/**
+ * Violation state slice
+ */
+export interface ViolationStateSlice {
+  total: number;
+  bySeverity: Record<Severity, number>;
+  activeFile: string | null;
+  activeFileCount: number;
+}
+
+/**
+ * UI state slice
+ */
+export interface UIStateSlice {
+  statusBarVisible: boolean;
+  sidebarExpanded: boolean;
+  activePanel: string | null;
+}
+
+/**
+ * User preferences (persisted)
+ */
+export interface PreferencesSlice {
+  autoScan: boolean;
+  showInlineHints: boolean;
+  severityFilter: Severity[];
+  categoryFilter: string[];
+}
+
+/**
+ * Complete extension state
+ */
+export interface ExtensionState {
+  connection: ConnectionStateSlice;
+  workspace: WorkspaceStateSlice;
+  patterns: PatternStateSlice;
+  violations: ViolationStateSlice;
+  ui: UIStateSlice;
+  preferences: PreferencesSlice;
+}
+
+/**
+ * State update function type
+ */
+export type StateUpdater = (draft: ExtensionState) => void;
+
+/**
+ * State selector function type
+ */
+export type StateSelector<T> = (state: ExtensionState) => T;
+
+/**
+ * State subscription callback
+ */
+export type StateSubscriber<T> = (value: T) => void;

package/src/types/vscode-types.ts

@@ -0,0 +1,40 @@
+/**
+ * VS Code-specific type definitions
+ * 
+ * Re-exports and extensions of VS Code types.
+ */
+
+import type * as vscode from 'vscode';
+
+/**
+ * Extended quick pick item with additional data
+ */
+export interface ExtendedQuickPickItem<T = unknown> extends vscode.QuickPickItem {
+  data?: T;
+}
+
+/**
+ * Tree item with generic data
+ */
+export interface DataTreeItem<T = unknown> extends vscode.TreeItem {
+  data?: T;
+}
+
+/**
+ * Webview message types
+ */
+export interface WebviewMessage<T = unknown> {
+  type: string;
+  requestId?: string;
+  data?: T;
+}
+
+/**
+ * Webview response types
+ */
+export interface WebviewResponse<T = unknown> {
+  type: string;
+  requestId: string;
+  data?: T;
+  error?: string;
+}

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

@@ -0,0 +1,252 @@
+/**
+ * DecorationController - Editor decoration management
+ * 
+ * Single responsibility: Apply visual decorations to editors.
+ */
+
+import * as vscode from 'vscode';
+
+import { createDecorationTypes, type DecorationTypes, type DecorationTypeKey } from './decoration-types.js';
+
+import type { ConfigManager } from '../../config/index.js';
+import type { DisplayConfig, Severity } from '../../types/index.js';
+
+/**
+ * Decoration controller for editor visuals
+ */
+export class DecorationController implements vscode.Disposable {
+  private readonly decorationTypes: DecorationTypes;
+  private readonly disposables: vscode.Disposable[] = [];
+  private config: DisplayConfig;
+
+  constructor(
+    context: vscode.ExtensionContext,
+    private readonly configManager: ConfigManager
+  ) {
+    this.decorationTypes = createDecorationTypes(context);
+    this.config = configManager.get('display');
+
+    this.setupEventHandlers();
+  }
+
+  /**
+   * 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);
+
+    // Filter to Drift diagnostics only
+    const driftDiagnostics = diagnostics.filter(d => d.source === 'drift');
+
+    // Clear all decorations first
+    this.clearDecorations(editor);
+
+    if (driftDiagnostics.length === 0) {return;}
+
+    // Apply gutter decorations
+    if (this.config.showGutterIcons) {
+      this.applyGutterDecorations(editor, driftDiagnostics);
+    }
+
+    // Apply inline hints
+    if (this.config.showInlineHints) {
+      this.applyInlineHints(editor, driftDiagnostics);
+    }
+  }
+
+  /**
+   * Clear all decorations from an editor
+   */
+  clearDecorations(editor: vscode.TextEditor): void {
+    for (const [, type] of this.decorationTypes) {
+      editor.setDecorations(type, []);
+    }
+  }
+
+  /**
+   * Refresh decorations for all visible editors
+   */
+  refreshAll(): void {
+    for (const editor of vscode.window.visibleTextEditors) {
+      this.updateDecorations(editor);
+    }
+  }
+
+  /**
+   * Dispose resources
+   */
+  dispose(): void {
+    for (const d of this.disposables) {
+      d.dispose();
+    }
+  }
+
+  private setupEventHandlers(): void {
+    // Update decorations when active editor changes
+    this.disposables.push(
+      vscode.window.onDidChangeActiveTextEditor(editor => {
+        if (editor) {
+          this.updateDecorations(editor);
+        }
+      })
+    );
+
+    // Update decorations when diagnostics change
+    this.disposables.push(
+      vscode.languages.onDidChangeDiagnostics(event => {
+        const editor = vscode.window.activeTextEditor;
+        if (editor && event.uris.some(uri => uri.toString() === editor.document.uri.toString())) {
+          this.updateDecorations(editor);
+        }
+      })
+    );
+
+    // Update config when it changes
+    this.disposables.push(
+      this.configManager.onConfigChange(event => {
+        if (event.section === 'display') {
+          this.config = event.newValue as DisplayConfig;
+          this.refreshAll();
+        }
+      })
+    );
+  }
+
+  private applyGutterDecorations(
+    editor: vscode.TextEditor,
+    diagnostics: vscode.Diagnostic[]
+  ): void {
+    // Group diagnostics by severity
+    const bySeverity = this.groupBySeverity(diagnostics);
+
+    for (const [severity, diags] of bySeverity) {
+      // Check if this severity is in the filter
+      if (!this.config.severityFilter.includes(severity)) {
+        continue;
+      }
+
+      const decorationType = this.decorationTypes.get(`gutter-${severity}` as DecorationTypeKey);
+      if (!decorationType) {continue;}
+
+      const decorations: vscode.DecorationOptions[] = diags.map(d => ({
+        range: d.range,
+        hoverMessage: this.buildHoverMessage(d),
+      }));
+
+      editor.setDecorations(decorationType, decorations);
+    }
+  }
+
+  private applyInlineHints(
+    editor: vscode.TextEditor,
+    diagnostics: vscode.Diagnostic[]
+  ): void {
+    const decorationType = this.decorationTypes.get('inline-hint');
+    if (!decorationType) {return;}
+
+    // Only show hints for filtered severities
+    const filtered = diagnostics.filter(d => {
+      const severity = this.diagnosticSeverityToString(d.severity);
+      return this.config.severityFilter.includes(severity);
+    });
+
+    // Group by line to avoid multiple hints on same line
+    const byLine = new Map<number, vscode.Diagnostic>();
+    for (const d of filtered) {
+      const line = d.range.start.line;
+      if (!byLine.has(line)) {
+        byLine.set(line, d);
+      }
+    }
+
+    const decorations: vscode.DecorationOptions[] = [];
+    for (const [, diagnostic] of byLine) {
+      decorations.push({
+        range: new vscode.Range(
+          diagnostic.range.end.line,
+          Number.MAX_SAFE_INTEGER,
+          diagnostic.range.end.line,
+          Number.MAX_SAFE_INTEGER
+        ),
+        renderOptions: {
+          after: {
+            contentText: ` ← ${diagnostic.message}`,
+          },
+        },
+      });
+    }
+
+    editor.setDecorations(decorationType, decorations);
+  }
+
+  private groupBySeverity(diagnostics: vscode.Diagnostic[]): Map<Severity, vscode.Diagnostic[]> {
+    const groups = new Map<Severity, vscode.Diagnostic[]>();
+
+    for (const d of diagnostics) {
+      const severity = this.diagnosticSeverityToString(d.severity);
+      const group = groups.get(severity) || [];
+      group.push(d);
+      groups.set(severity, group);
+    }
+
+    return groups;
+  }
+
+  private diagnosticSeverityToString(severity: vscode.DiagnosticSeverity): Severity {
+    switch (severity) {
+      case vscode.DiagnosticSeverity.Error:
+        return 'error';
+      case vscode.DiagnosticSeverity.Warning:
+        return 'warning';
+      case vscode.DiagnosticSeverity.Information:
+        return 'info';
+      case vscode.DiagnosticSeverity.Hint:
+        return 'hint';
+    }
+  }
+
+  private buildHoverMessage(diagnostic: vscode.Diagnostic): vscode.MarkdownString {
+    const md = new vscode.MarkdownString();
+    md.isTrusted = true;
+    md.supportThemeIcons = true;
+
+    const icon = this.getSeverityIcon(diagnostic.severity);
+    md.appendMarkdown(`${icon} **${diagnostic.message}**\n\n`);
+
+    if (diagnostic.code) {
+      md.appendMarkdown(`Pattern: \`${diagnostic.code}\`\n\n`);
+    }
+
+    md.appendMarkdown(`---\n\n`);
+    md.appendMarkdown(`[Quick Fix](command:editor.action.quickFix) | `);
+    md.appendMarkdown(`[Ignore](command:drift.ignoreOnce)\n`);
+
+    return md;
+  }
+
+  private getSeverityIcon(severity: vscode.DiagnosticSeverity): string {
+    switch (severity) {
+      case vscode.DiagnosticSeverity.Error:
+        return '$(error)';
+      case vscode.DiagnosticSeverity.Warning:
+        return '$(warning)';
+      case vscode.DiagnosticSeverity.Information:
+        return '$(info)';
+      case vscode.DiagnosticSeverity.Hint:
+        return '$(lightbulb)';
+    }
+  }
+}
+
+/**
+ * Factory function for creating decoration controller
+ */
+export function createDecorationController(
+  context: vscode.ExtensionContext,
+  configManager: ConfigManager
+): DecorationController {
+  return new DecorationController(context, configManager);
+}

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

@@ -0,0 +1,129 @@
+/**
+ * Decoration type definitions
+ * 
+ * Single responsibility: Create VS Code decoration types.
+ */
+
+import * as vscode from 'vscode';
+
+import type { Severity } from '../../types/index.js';
+
+/**
+ * Decoration type keys
+ */
+export type DecorationTypeKey = 
+  | `gutter-${Severity}`
+  | 'inline-hint'
+  | `background-${Severity}`;
+
+/**
+ * Decoration types container
+ */
+export type DecorationTypes = Map<DecorationTypeKey, vscode.TextEditorDecorationType>;
+
+/**
+ * Gutter icon colors by severity
+ */
+const GUTTER_COLORS: Record<Severity, string> = {
+  error: '#f44336',
+  warning: '#ff9800',
+  info: '#2196f3',
+  hint: '#4caf50',
+};
+
+/**
+ * Background colors by severity (with alpha)
+ */
+const BACKGROUND_COLORS: Record<Severity, string> = {
+  error: 'rgba(244, 67, 54, 0.1)',
+  warning: 'rgba(255, 152, 0, 0.1)',
+  info: 'rgba(33, 150, 243, 0.1)',
+  hint: 'rgba(76, 175, 80, 0.1)',
+};
+
+/**
+ * Create all decoration types
+ */
+export function createDecorationTypes(
+  context: vscode.ExtensionContext
+): DecorationTypes {
+  const types = new Map<DecorationTypeKey, vscode.TextEditorDecorationType>();
+  const severities: Severity[] = ['error', 'warning', 'info', 'hint'];
+
+  // Create gutter decorations
+  for (const severity of severities) {
+    const type = vscode.window.createTextEditorDecorationType({
+      gutterIconPath: createGutterIcon(context, severity),
+      gutterIconSize: 'contain',
+    });
+    types.set(`gutter-${severity}`, type);
+    context.subscriptions.push(type);
+  }
+
+  // Create inline hint decoration
+  const inlineHint = vscode.window.createTextEditorDecorationType({
+    after: {
+      margin: '0 0 0 1em',
+      color: new vscode.ThemeColor('editorCodeLens.foreground'),
+      fontStyle: 'italic',
+      fontWeight: 'normal',
+    },
+  });
+  types.set('inline-hint', inlineHint);
+  context.subscriptions.push(inlineHint);
+
+  // Create background decorations
+  for (const severity of severities) {
+    const type = vscode.window.createTextEditorDecorationType({
+      backgroundColor: BACKGROUND_COLORS[severity],
+      isWholeLine: true,
+    });
+    types.set(`background-${severity}`, type);
+    context.subscriptions.push(type);
+  }
+
+  return types;
+}
+
+/**
+ * Create a gutter icon for a severity
+ */
+function createGutterIcon(
+  context: vscode.ExtensionContext,
+  severity: Severity
+): vscode.Uri {
+  // Use built-in icons via ThemeIcon
+  // For custom icons, you'd create SVGs in resources/
+  const iconName = getIconName(severity);
+  return vscode.Uri.joinPath(context.extensionUri, 'resources', 'icons', `${iconName}.svg`);
+}
+
+/**
+ * Get icon name for severity
+ */
+function getIconName(severity: Severity): string {
+  switch (severity) {
+    case 'error':
+      return 'error';
+    case 'warning':
+      return 'warning';
+    case 'info':
+      return 'info';
+    case 'hint':
+      return 'lightbulb';
+  }
+}
+
+/**
+ * Get gutter color for severity
+ */
+export function getGutterColor(severity: Severity): string {
+  return GUTTER_COLORS[severity];
+}
+
+/**
+ * Get background color for severity
+ */
+export function getBackgroundColor(severity: Severity): string {
+  return BACKGROUND_COLORS[severity];
+}

package/src/ui/decorations/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Decorations module exports
+ */
+
+export { DecorationController, createDecorationController } from './decoration-controller.js';
+export type { DecorationTypes } from './decoration-types.js';
+export { createDecorationTypes } from './decoration-types.js';

package/src/ui/index.ts

@@ -0,0 +1,7 @@
+/**
+ * UI module exports
+ */
+
+export { StatusBarController, createStatusBar } from './status-bar/status-bar-controller.js';
+export { DecorationController, createDecorationController } from './decorations/decoration-controller.js';
+export { NotificationService, createNotificationService } from './notifications/notification-service.js';

package/src/ui/notifications/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Notifications module exports
+ */
+
+export { NotificationService, createNotificationService } from './notification-service.js';