statusbar-quick-actions 0.0.10

package/src/preset-manager.ts

@@ -0,0 +1,406 @@
+/**
+ * Preset Management for StatusBar Quick Actions
+ * Handles preset storage, CRUD operations, and application
+ */
+
+import * as vscode from "vscode";
+import * as fs from "fs";
+import { PresetConfig, PresetApplicationMode, ExtensionConfig } from "./types";
+
+/**
+ * Preset Manager
+ * Manages configuration presets for quick button setup
+ */
+export class PresetManager {
+  private static readonly PRESET_STORAGE_KEY = "statusbarQuickActions.presets";
+  private context: vscode.ExtensionContext | null = null;
+
+  /**
+   * Initialize the preset manager
+   */
+  public initialize(context: vscode.ExtensionContext): void {
+    this.context = context;
+  }
+
+  /**
+   * Get all presets
+   */
+  public getAllPresets(): PresetConfig[] {
+    if (!this.context) {
+      console.error("PresetManager not initialized");
+      return [];
+    }
+
+    try {
+      const presetsJson = this.context.globalState.get<string>(
+        PresetManager.PRESET_STORAGE_KEY,
+        "[]",
+      );
+      const presets = JSON.parse(presetsJson) as PresetConfig[];
+
+      // Convert date strings back to Date objects
+      return presets.map((preset) => ({
+        ...preset,
+        metadata: preset.metadata
+          ? {
+              ...preset.metadata,
+              created: new Date(preset.metadata.created),
+              modified: new Date(preset.metadata.modified),
+            }
+          : undefined,
+      }));
+    } catch (error) {
+      console.error("Failed to load presets:", error);
+      return [];
+    }
+  }
+
+  /**
+   * Get a preset by ID
+   */
+  public getPreset(presetId: string): PresetConfig | null {
+    const presets = this.getAllPresets();
+    return presets.find((p) => p.id === presetId) || null;
+  }
+
+  /**
+   * Save a preset
+   */
+  public async savePreset(preset: PresetConfig): Promise<void> {
+    if (!this.context) {
+      throw new Error("PresetManager not initialized");
+    }
+
+    try {
+      const presets = this.getAllPresets();
+      const existingIndex = presets.findIndex((p) => p.id === preset.id);
+
+      const now = new Date();
+      const presetWithMetadata: PresetConfig = {
+        ...preset,
+        metadata: {
+          created: preset.metadata?.created || now,
+          modified: now,
+          author: preset.metadata?.author,
+          tags: preset.metadata?.tags,
+        },
+      };
+
+      if (existingIndex >= 0) {
+        // Update existing preset
+        presets[existingIndex] = presetWithMetadata;
+      } else {
+        // Add new preset
+        presets.push(presetWithMetadata);
+      }
+
+      await this.context.globalState.update(
+        PresetManager.PRESET_STORAGE_KEY,
+        JSON.stringify(presets, null, 2),
+      );
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to save preset: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Delete a preset
+   */
+  public async deletePreset(presetId: string): Promise<void> {
+    if (!this.context) {
+      throw new Error("PresetManager not initialized");
+    }
+
+    try {
+      const presets = this.getAllPresets();
+      const filteredPresets = presets.filter((p) => p.id !== presetId);
+
+      if (filteredPresets.length === presets.length) {
+        throw new Error(`Preset with ID '${presetId}' not found`);
+      }
+
+      await this.context.globalState.update(
+        PresetManager.PRESET_STORAGE_KEY,
+        JSON.stringify(filteredPresets, null, 2),
+      );
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to delete preset: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Create a preset from current configuration
+   */
+  public async createPresetFromConfig(
+    name: string,
+    description: string,
+    currentConfig: ExtensionConfig,
+    tags?: string[],
+  ): Promise<PresetConfig> {
+    const preset: PresetConfig = {
+      id: `preset_${Date.now()}`,
+      name,
+      description,
+      buttons: currentConfig.buttons,
+      theme: currentConfig.theme,
+      metadata: {
+        created: new Date(),
+        modified: new Date(),
+        tags,
+      },
+    };
+
+    await this.savePreset(preset);
+    return preset;
+  }
+
+  /**
+   * Apply a preset to current configuration
+   */
+  public applyPreset(
+    preset: PresetConfig,
+    currentConfig: ExtensionConfig,
+    mode: PresetApplicationMode = "replace",
+  ): ExtensionConfig {
+    let newConfig: ExtensionConfig;
+
+    switch (mode) {
+      case "replace":
+        // Replace all buttons with preset buttons
+        newConfig = {
+          ...currentConfig,
+          buttons: [...preset.buttons],
+        };
+        break;
+
+      case "merge": {
+        // Merge preset buttons, overwriting buttons with same ID
+        const mergedButtons = [...currentConfig.buttons];
+        preset.buttons.forEach((presetButton) => {
+          const existingIndex = mergedButtons.findIndex(
+            (b) => b.id === presetButton.id,
+          );
+          if (existingIndex >= 0) {
+            mergedButtons[existingIndex] = presetButton;
+          } else {
+            mergedButtons.push(presetButton);
+          }
+        });
+        newConfig = {
+          ...currentConfig,
+          buttons: mergedButtons,
+        };
+        break;
+      }
+
+      case "append": {
+        // Append preset buttons to existing buttons
+        const appendedButtons = [...currentConfig.buttons, ...preset.buttons];
+        newConfig = {
+          ...currentConfig,
+          buttons: appendedButtons,
+        };
+        break;
+      }
+
+      default:
+        throw new Error(`Unknown preset application mode: ${mode}`);
+    }
+
+    // Apply theme if present in preset
+    if (preset.theme) {
+      newConfig.theme = preset.theme;
+    }
+
+    return newConfig;
+  }
+
+  /**
+   * Export preset to JSON file
+   */
+  public async exportPreset(preset: PresetConfig): Promise<void> {
+    const uri = await vscode.window.showSaveDialog({
+      filters: { JSON: ["json"] },
+      defaultUri: vscode.Uri.file(`${preset.name}.preset.json`),
+    });
+
+    if (!uri) {
+      return;
+    }
+
+    try {
+      fs.writeFileSync(uri.fsPath, JSON.stringify(preset, null, 2));
+      vscode.window.showInformationMessage(
+        `✅ Preset "${preset.name}" exported to ${uri.fsPath}`,
+      );
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to export preset: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Import preset from JSON file
+   */
+  public async importPreset(): Promise<PresetConfig | null> {
+    const uri = await vscode.window.showOpenDialog({
+      filters: { JSON: ["json"] },
+      canSelectMany: false,
+    });
+
+    if (!uri || uri.length === 0) {
+      return null;
+    }
+
+    try {
+      const content = fs.readFileSync(uri[0].fsPath, "utf8");
+      const preset = JSON.parse(content) as PresetConfig;
+
+      // Validate preset structure
+      if (!preset.id || !preset.name || !preset.buttons) {
+        throw new Error(
+          "Invalid preset file: missing required fields (id, name, buttons)",
+        );
+      }
+
+      // Generate new ID to avoid conflicts
+      preset.id = `preset_${Date.now()}`;
+      preset.metadata = {
+        created: new Date(),
+        modified: new Date(),
+        author: preset.metadata?.author,
+        tags: preset.metadata?.tags,
+      };
+
+      await this.savePreset(preset);
+      vscode.window.showInformationMessage(
+        `✅ Preset "${preset.name}" imported successfully`,
+      );
+
+      return preset;
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      vscode.window.showErrorMessage(
+        `Failed to import preset: ${errorMessage}`,
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Duplicate a preset
+   */
+  public async duplicatePreset(presetId: string): Promise<PresetConfig | null> {
+    const original = this.getPreset(presetId);
+    if (!original) {
+      throw new Error(`Preset with ID '${presetId}' not found`);
+    }
+
+    const duplicate: PresetConfig = {
+      ...original,
+      id: `preset_${Date.now()}`,
+      name: `${original.name} (Copy)`,
+      metadata: {
+        created: new Date(),
+        modified: new Date(),
+        author: original.metadata?.author,
+        tags: original.metadata?.tags,
+      },
+    };
+
+    await this.savePreset(duplicate);
+    return duplicate;
+  }
+
+  /**
+   * Search presets by name or tags
+   */
+  public searchPresets(query: string): PresetConfig[] {
+    const presets = this.getAllPresets();
+    const lowerQuery = query.toLowerCase();
+
+    return presets.filter(
+      (preset) =>
+        preset.name.toLowerCase().includes(lowerQuery) ||
+        preset.description?.toLowerCase().includes(lowerQuery) ||
+        preset.metadata?.tags?.some((tag) =>
+          tag.toLowerCase().includes(lowerQuery),
+        ),
+    );
+  }
+
+  /**
+   * Get preset count
+   */
+  public getPresetCount(): number {
+    return this.getAllPresets().length;
+  }
+
+  /**
+   * Clear all presets (with confirmation)
+   */
+  public async clearAllPresets(): Promise<void> {
+    if (!this.context) {
+      throw new Error("PresetManager not initialized");
+    }
+
+    await this.context.globalState.update(
+      PresetManager.PRESET_STORAGE_KEY,
+      "[]",
+    );
+  }
+
+  /**
+   * Validate preset configuration
+   */
+  public validatePreset(preset: PresetConfig): {
+    isValid: boolean;
+    errors: string[];
+  } {
+    const errors: string[] = [];
+
+    if (!preset.id || typeof preset.id !== "string") {
+      errors.push("Preset ID is required and must be a string");
+    }
+
+    if (!preset.name || typeof preset.name !== "string") {
+      errors.push("Preset name is required and must be a string");
+    }
+
+    if (!Array.isArray(preset.buttons)) {
+      errors.push("Preset buttons must be an array");
+    } else {
+      preset.buttons.forEach((button, index) => {
+        if (!button.id || typeof button.id !== "string") {
+          errors.push(`Button ${index}: ID is required and must be a string`);
+        }
+        if (!button.text && !button.icon) {
+          errors.push(`Button ${index}: Either text or icon is required`);
+        }
+        if (!button.command || typeof button.command !== "object") {
+          errors.push(
+            `Button ${index}: Command is required and must be an object`,
+          );
+        }
+      });
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors,
+    };
+  }
+
+  /**
+   * Dispose of resources
+   */
+  public dispose(): void {
+    // Cleanup if needed
+  }
+}

package/src/theme.ts

@@ -0,0 +1,318 @@
+/**
+ * Theme management for StatusBar Quick Actions
+ */
+
+import * as vscode from "vscode";
+import { ThemeConfig } from "./types";
+
+export class ThemeManager {
+  private context: vscode.ExtensionContext | null = null;
+  private currentTheme: ThemeConfig | null = null;
+
+  /**
+   * Initialize the theme manager
+   */
+  public async initialize(context: vscode.ExtensionContext): Promise<void> {
+    this.context = context;
+    await this.loadTheme();
+    this.setupThemeWatching();
+  }
+
+  /**
+   * Load theme from configuration
+   */
+  private async loadTheme(): Promise<void> {
+    try {
+      const config = vscode.workspace.getConfiguration(
+        "statusbarQuickActions.settings",
+      );
+      const themeConfig = config.get<ThemeConfig>("theme");
+
+      if (themeConfig) {
+        this.currentTheme = themeConfig as ThemeConfig;
+      } else {
+        // Use default theme if not configured
+        this.currentTheme = this.getDefaultTheme();
+      }
+    } catch (error) {
+      console.error("Error loading theme:", error);
+      this.currentTheme = this.getDefaultTheme();
+    }
+  }
+
+  /**
+   * Apply theme to a statusbar item
+   */
+  public applyThemeToStatusBarItem(item: vscode.StatusBarItem): void {
+    if (!this.currentTheme) {
+      return;
+    }
+
+    try {
+      const colors = this.getCurrentThemeColors();
+      if (colors.foreground) {
+        item.color = new vscode.ThemeColor(colors.foreground);
+      }
+      if (colors.background) {
+        item.backgroundColor = new vscode.ThemeColor(colors.background);
+      }
+    } catch (error) {
+      console.error("Error applying theme to statusbar item:", error);
+    }
+  }
+
+  /**
+   * Get current theme colors
+   */
+  public getCurrentThemeColors(): { foreground?: string; background?: string } {
+    if (!this.currentTheme) {
+      return {};
+    }
+
+    try {
+      const themeType = this.getCurrentThemeType();
+      const theme = this.currentTheme[themeType];
+      if (!theme || typeof theme !== "object") {
+        return {};
+      }
+
+      return {
+        foreground: theme.button?.foreground,
+        background: theme.button?.background,
+      };
+    } catch (error) {
+      console.error("Error getting current theme colors:", error);
+      return {};
+    }
+  }
+
+  /**
+   * Get current theme type (dark/light/highContrast)
+   */
+  private getCurrentThemeType(): "dark" | "light" | "highContrast" {
+    if (!this.currentTheme) {
+      return "dark";
+    }
+
+    const mode = this.currentTheme.mode;
+    if (mode === "auto") {
+      // Detect from VSCode theme
+      const colorTheme = vscode.workspace
+        .getConfiguration()
+        .get("workbench.colorTheme");
+      const isDark =
+        colorTheme?.toString().toLowerCase().includes("dark") ||
+        colorTheme?.toString().toLowerCase().includes("black") ||
+        colorTheme?.toString().toLowerCase().includes("dimmed");
+
+      // Check for high contrast
+      const isHighContrast =
+        vscode.workspace
+          .getConfiguration()
+          .get("accessibility.verbosityNotifications") === "verbose";
+
+      return isHighContrast ? "highContrast" : isDark ? "dark" : "light";
+    } else if (mode === "highContrast") {
+      return "highContrast";
+    } else if (mode === "dark") {
+      return "dark";
+    } else {
+      return "light";
+    }
+  }
+
+  /**
+   * Set up theme change watching
+   */
+  private setupThemeWatching(): void {
+    if (!this.context) {
+      return;
+    }
+
+    // Watch for theme changes
+    const disposable = vscode.workspace.onDidChangeConfiguration((event) => {
+      if (
+        event.affectsConfiguration("workbench.colorTheme") ||
+        event.affectsConfiguration("accessibility")
+      ) {
+        this.updateTheme();
+      }
+    });
+
+    this.context.subscriptions.push(disposable);
+  }
+
+  /**
+   * Update current theme
+   */
+  private updateTheme(): void {
+    // Reload theme from configuration
+    this.loadTheme();
+  }
+
+  /**
+   * Get theme for executing state
+   */
+  public getExecutingThemeColors(): {
+    foreground?: string;
+    background?: string;
+  } {
+    if (!this.currentTheme) {
+      return {};
+    }
+
+    try {
+      const themeType = this.getCurrentThemeType();
+      const theme = this.currentTheme[themeType];
+      if (!theme || typeof theme !== "object") {
+        return {};
+      }
+
+      return {
+        foreground: theme.executing?.foreground,
+        background: theme.executing?.background,
+      };
+    } catch (error) {
+      console.error("Error getting executing theme colors:", error);
+      return {};
+    }
+  }
+
+  /**
+   * Get theme for error state
+   */
+  public getErrorThemeColors(): { foreground?: string; background?: string } {
+    if (!this.currentTheme) {
+      return {};
+    }
+
+    try {
+      const themeType = this.getCurrentThemeType();
+      const theme = this.currentTheme[themeType];
+      if (!theme || typeof theme !== "object") {
+        return {};
+      }
+
+      return {
+        foreground: theme.error?.foreground,
+        background: theme.error?.background,
+      };
+    } catch (error) {
+      console.error("Error getting error theme colors:", error);
+      return {};
+    }
+  }
+
+  /**
+   * Export theme configuration
+   */
+  public exportTheme(): ThemeConfig | null {
+    return this.currentTheme;
+  }
+
+  /**
+   * Import theme configuration
+   */
+  public async importTheme(theme: ThemeConfig): Promise<void> {
+    this.currentTheme = theme;
+    // Trigger theme update
+    this.updateTheme();
+  }
+
+  /**
+   * Reset to default theme
+   */
+  public async resetToDefault(): Promise<void> {
+    this.currentTheme = this.getDefaultTheme();
+    this.updateTheme();
+  }
+
+  /**
+   * Get default theme configuration
+   */
+  private getDefaultTheme(): ThemeConfig {
+    return {
+      mode: "auto",
+      dark: {
+        button: {
+          foreground: "#ffffff",
+          background: "#6c757d",
+        },
+        executing: {
+          foreground: "#ffffff",
+          background: "#007acc",
+        },
+        error: {
+          foreground: "#ffffff",
+          background: "#dc3545",
+        },
+      },
+      light: {
+        button: {
+          foreground: "#ffffff",
+          background: "#6c757d",
+        },
+        executing: {
+          foreground: "#ffffff",
+          background: "#007acc",
+        },
+        error: {
+          foreground: "#ffffff",
+          background: "#dc3545",
+        },
+      },
+      highContrast: {
+        button: {
+          foreground: "#ffffff",
+          background: "#000000",
+        },
+        executing: {
+          foreground: "#000000",
+          background: "#ffff00",
+        },
+        error: {
+          foreground: "#ffffff",
+          background: "#ff0000",
+        },
+      },
+    };
+  }
+
+  /**
+   * Check if high contrast mode is enabled
+   */
+  public isHighContrastMode(): boolean {
+    return this.getCurrentThemeType() === "highContrast";
+  }
+
+  /**
+   * Get recommended color scheme for accessibility
+   */
+  public getAccessibilityColors(): { foreground: string; background: string } {
+    const themeType = this.getCurrentThemeType();
+
+    if (themeType === "highContrast") {
+      return {
+        foreground: "#ffffff",
+        background: "#000000",
+      };
+    } else if (themeType === "dark") {
+      return {
+        foreground: "#ffffff",
+        background: "#333333",
+      };
+    } else {
+      return {
+        foreground: "#000000",
+        background: "#cccccc",
+      };
+    }
+  }
+
+  /**
+   * Dispose of resources
+   */
+  public dispose(): void {
+    this.context = null;
+  }
+}