statusbar-quick-actions 0.0.10 → 0.0.11

package/out/config-cli.js

@@ -0,0 +1,905 @@
+#!/usr/bin/env bun
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsError = exports.TimeoutError = exports.ValidationError = exports.ConfigCLIError = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const console_clear_1 = __importDefault(require("console-clear"));
+const package_json_1 = __importDefault(require("../package.json"));
+const CONFIG = {
+    banner: "=".repeat(50),
+    appName: "Statusbar Quick Actions - Config CLI",
+    separator: "\n",
+    version: package_json_1.default.version,
+    maxRetries: 3,
+    timeoutMs: 30000,
+    colors: {
+        primary: "\x1b[36m",
+        success: "\x1b[32m",
+        error: "\x1b[31m",
+        warning: "\x1b[33m",
+        reset: "\x1b[0m",
+        bold: "\x1b[1m",
+        dim: "\x1b[2m",
+    },
+};
+const BUILTIN_PRESETS = {
+    "node-dev": {
+        name: "Node.js Development",
+        description: "Common Node.js development tasks",
+        buttons: [
+            {
+                id: "npm_start",
+                text: "▶️ Start",
+                tooltip: "Start the application",
+                command: { type: "npm", script: "start" },
+                enabled: true,
+                alignment: "left",
+                priority: 100,
+            },
+            {
+                id: "npm_test",
+                text: "🧪 Test",
+                tooltip: "Run tests",
+                command: { type: "npm", script: "test" },
+                enabled: true,
+                alignment: "left",
+                priority: 99,
+            },
+            {
+                id: "npm_build",
+                text: "🔨 Build",
+                tooltip: "Build the project",
+                command: { type: "npm", script: "build" },
+                enabled: true,
+                alignment: "left",
+                priority: 98,
+            },
+        ],
+        metadata: {
+            created: new Date(),
+            modified: new Date(),
+            author: "StatusBar Quick Actions",
+        },
+    },
+    "bun-dev": {
+        name: "Bun Development",
+        description: "Common Bun development tasks",
+        buttons: [
+            {
+                id: "bun_dev",
+                text: "⚡ Dev",
+                tooltip: "Start development server",
+                command: { type: "bun", script: "dev" },
+                enabled: true,
+                alignment: "left",
+                priority: 100,
+            },
+            {
+                id: "bun_test",
+                text: "🧪 Test",
+                tooltip: "Run tests with Bun",
+                command: { type: "bun", script: "test" },
+                enabled: true,
+                alignment: "left",
+                priority: 99,
+            },
+            {
+                id: "bun_build",
+                text: "🔨 Build",
+                tooltip: "Build with Bun",
+                command: { type: "bun", script: "build" },
+                enabled: true,
+                alignment: "left",
+                priority: 98,
+            },
+        ],
+        metadata: {
+            created: new Date(),
+            modified: new Date(),
+            author: "StatusBar Quick Actions",
+        },
+    },
+    "git-workflow": {
+        name: "Git Workflow",
+        description: "Common Git operations",
+        buttons: [
+            {
+                id: "git_status",
+                text: "📊 Status",
+                tooltip: "Show git status",
+                command: { type: "shell", command: "git status" },
+                enabled: true,
+                alignment: "right",
+                priority: 100,
+            },
+            {
+                id: "git_pull",
+                text: "⬇️ Pull",
+                tooltip: "Pull from remote",
+                command: { type: "shell", command: "git pull" },
+                enabled: true,
+                alignment: "right",
+                priority: 99,
+            },
+            {
+                id: "git_push",
+                text: "⬆️ Push",
+                tooltip: "Push to remote",
+                command: { type: "shell", command: "git push" },
+                enabled: true,
+                alignment: "right",
+                priority: 98,
+            },
+        ],
+        metadata: {
+            created: new Date(),
+            modified: new Date(),
+            author: "StatusBar Quick Actions",
+        },
+    },
+};
+const MENU_OPTIONS = [
+    {
+        key: "1",
+        label: "View Current Configuration",
+        description: "Display current button configurations",
+        action: viewCurrentConfiguration,
+        requiresConfirmation: false,
+    },
+    {
+        key: "2",
+        label: "Apply Preset",
+        description: "Apply a built-in preset configuration",
+        action: applyPreset,
+        requiresConfirmation: true,
+    },
+    {
+        key: "3",
+        label: "Add Button",
+        description: "Add a new button to the status bar",
+        action: addButton,
+        requiresConfirmation: false,
+    },
+    {
+        key: "4",
+        label: "Remove Button",
+        description: "Remove a button from the status bar",
+        action: removeButton,
+        requiresConfirmation: true,
+    },
+    {
+        key: "5",
+        label: "Toggle Debug Mode",
+        description: "Enable or disable debug logging",
+        action: toggleDebugMode,
+        requiresConfirmation: false,
+    },
+    {
+        key: "6",
+        label: "Export Configuration",
+        description: "Export current configuration to a file",
+        action: exportConfiguration,
+        requiresConfirmation: false,
+    },
+    {
+        key: "7",
+        label: "Import Configuration",
+        description: "Import configuration from a file",
+        action: importConfiguration,
+        requiresConfirmation: true,
+    },
+    {
+        key: "8",
+        label: "Reset to Defaults",
+        description: "Reset all settings to default values",
+        action: resetToDefaults,
+        requiresConfirmation: true,
+    },
+    {
+        key: "9",
+        label: "Help",
+        description: "Show help and usage information",
+        action: showHelp,
+        requiresConfirmation: false,
+    },
+];
+class ConfigCLIError extends Error {
+    code;
+    suggestion;
+    constructor(message, code, suggestion) {
+        super(message);
+        this.code = code;
+        this.suggestion = suggestion;
+        this.name = "ConfigCLIError";
+    }
+}
+exports.ConfigCLIError = ConfigCLIError;
+class ValidationError extends ConfigCLIError {
+    constructor(message, suggestion) {
+        super(message, "VALIDATION_ERROR", suggestion);
+        this.name = "ValidationError";
+    }
+}
+exports.ValidationError = ValidationError;
+class TimeoutError extends ConfigCLIError {
+    constructor(operation, timeoutMs) {
+        super(`${operation} operation timed out after ${timeoutMs}ms`, "TIMEOUT_ERROR");
+        this.name = "TimeoutError";
+    }
+}
+exports.TimeoutError = TimeoutError;
+class SettingsError extends ConfigCLIError {
+    constructor(message, suggestion) {
+        super(message, "SETTINGS_ERROR", suggestion);
+        this.name = "SettingsError";
+    }
+}
+exports.SettingsError = SettingsError;
+class ConsoleUI {
+    static clear() {
+        (0, console_clear_1.default)(true);
+    }
+    static printColored(text, color) {
+        console.log(`${color}${text}${CONFIG.colors.reset}`);
+    }
+    static printBanner() {
+        const { colors } = CONFIG;
+        console.log(`${colors.primary}${CONFIG.banner}${CONFIG.colors.reset}`);
+        console.log(`${colors.bold}${colors.primary}${CONFIG.appName} v${CONFIG.version}${CONFIG.colors.reset}`);
+        console.log(`${colors.primary}${CONFIG.banner}${CONFIG.colors.reset}`);
+        console.log(CONFIG.separator);
+    }
+    static printMenu() {
+        console.log("What would you like to do?", CONFIG.separator);
+        for (const option of MENU_OPTIONS) {
+            console.log(`  ${option.key}. ${option.label} - ${option.description}`);
+        }
+        console.log(CONFIG.banner);
+        console.log("Enter your choice (or 'q' to quit): ");
+    }
+    static printError(message, suggestion) {
+        this.printColored(`❌ ${message}`, CONFIG.colors.error);
+        if (suggestion) {
+            this.printColored(`💡 ${suggestion}`, CONFIG.colors.warning);
+        }
+        console.log(CONFIG.separator);
+    }
+    static printSuccess(message) {
+        this.printColored(`✅ ${message}`, CONFIG.colors.success);
+        console.log(CONFIG.separator);
+    }
+    static printWarning(message) {
+        this.printColored(`⚠️  ${message}`, CONFIG.colors.warning);
+        console.log(CONFIG.separator);
+    }
+    static printInfo(message) {
+        this.printColored(`ℹ️  ${message}`, CONFIG.colors.primary);
+        console.log(CONFIG.separator);
+    }
+    static printDivider(char = "─") {
+        console.log(char.repeat(50));
+    }
+    static printTable(headers, rows) {
+        const colWidths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] || "").length)));
+        const headerRow = headers.map((h, i) => h.padEnd(colWidths[i])).join(" | ");
+        console.log(headerRow);
+        console.log(colWidths.map((w) => "─".repeat(w)).join("─┼─"));
+        rows.forEach((row) => {
+            console.log(row.map((cell, i) => (cell || "").padEnd(colWidths[i])).join(" | "));
+        });
+    }
+}
+class SettingsManager {
+    static getUserSettingsPath() {
+        const platform = process.platform;
+        let settingsDir;
+        if (platform === "win32") {
+            settingsDir = (0, path_1.join)(process.env.APPDATA || (0, path_1.join)((0, os_1.homedir)(), "AppData", "Roaming"), "Code", "User");
+        }
+        else if (platform === "darwin") {
+            settingsDir = (0, path_1.join)((0, os_1.homedir)(), "Library", "Application Support", "Code", "User");
+        }
+        else {
+            settingsDir = (0, path_1.join)((0, os_1.homedir)(), ".config", "Code", "User");
+        }
+        return (0, path_1.join)(settingsDir, "settings.json");
+    }
+    static getWorkspaceSettingsPath() {
+        const workspaceRoot = process.cwd();
+        return (0, path_1.join)(workspaceRoot, ".vscode", "settings.json");
+    }
+    static getSettingsPath(location) {
+        return location === "user"
+            ? this.getUserSettingsPath()
+            : this.getWorkspaceSettingsPath();
+    }
+    static readSettings(location) {
+        const settingsPath = this.getSettingsPath(location);
+        if (!(0, fs_1.existsSync)(settingsPath)) {
+            const settingsDir = (0, path_1.dirname)(settingsPath);
+            if (!(0, fs_1.existsSync)(settingsDir)) {
+                (0, fs_1.mkdirSync)(settingsDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(settingsPath, "{}", "utf-8");
+            return {};
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(settingsPath, "utf-8");
+            const cleanedContent = content
+                .replace(/\/\/.*$/gm, "")
+                .replace(/\/\*[\s\S]*?\*\//g, "")
+                .replace(/,(\s*[}\]])/g, "$1");
+            return JSON.parse(cleanedContent);
+        }
+        catch (error) {
+            throw new SettingsError(`Failed to read settings from ${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "Check if the file is valid JSON");
+        }
+    }
+    static writeSettings(location, settings) {
+        const settingsPath = this.getSettingsPath(location);
+        const settingsDir = (0, path_1.dirname)(settingsPath);
+        if (!(0, fs_1.existsSync)(settingsDir)) {
+            (0, fs_1.mkdirSync)(settingsDir, { recursive: true });
+        }
+        try {
+            const content = JSON.stringify(settings, null, 2);
+            (0, fs_1.writeFileSync)(settingsPath, content, "utf-8");
+        }
+        catch (error) {
+            throw new SettingsError(`Failed to write settings to ${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "Check if you have write permissions");
+        }
+    }
+    static getButtons(location) {
+        const settings = this.readSettings(location);
+        return settings["statusbarQuickActions.buttons"] || [];
+    }
+    static setButtons(location, buttons) {
+        const settings = this.readSettings(location);
+        settings["statusbarQuickActions.buttons"] = buttons;
+        this.writeSettings(location, settings);
+    }
+    static getDebugMode(location) {
+        const settings = this.readSettings(location);
+        return settings["statusbarQuickActions.settings.debug"] || false;
+    }
+    static setDebugMode(location, enabled) {
+        const settings = this.readSettings(location);
+        settings["statusbarQuickActions.settings.debug"] = enabled;
+        this.writeSettings(location, settings);
+    }
+}
+class InputValidator {
+    static validateChoice(input) {
+        const trimmedInput = input.trim().toLowerCase();
+        if (!trimmedInput) {
+            return {
+                isValid: false,
+                error: "Please enter a valid choice",
+                suggestion: `Type a number (1-${MENU_OPTIONS.length}) or 'q' to quit`,
+            };
+        }
+        if (this.isQuitCommand(trimmedInput)) {
+            return { isValid: false, value: "quit" };
+        }
+        const option = MENU_OPTIONS.find((opt) => opt.key === trimmedInput);
+        if (option) {
+            return { isValid: true, value: trimmedInput };
+        }
+        const suggestions = this.getSuggestions(trimmedInput);
+        return {
+            isValid: false,
+            error: `Invalid choice '${input}'`,
+            suggestion: suggestions.length > 0
+                ? `Did you mean: ${suggestions.join(", ")}?`
+                : `Please select a valid option (1-${MENU_OPTIONS.length}) or 'q' to quit`,
+        };
+    }
+    static isQuitCommand(input) {
+        return ["q", "quit", "exit", "x"].includes(input);
+    }
+    static getSuggestions(input) {
+        const suggestions = [];
+        if (/^\d+$/.test(input)) {
+            const num = parseInt(input, 10);
+            if (num > 0 && num <= MENU_OPTIONS.length + 5) {
+                suggestions.push(`${num}`);
+            }
+        }
+        for (const option of MENU_OPTIONS) {
+            if (option.label.toLowerCase().includes(input) || option.key === input) {
+                suggestions.push(option.key);
+            }
+        }
+        return suggestions.slice(0, 3);
+    }
+}
+class InputHandler {
+    static async getInput(timeoutMs = CONFIG.timeoutMs) {
+        try {
+            if (process.argv.length > 2) {
+                const arg = process.argv[2];
+                return arg;
+            }
+            return await Promise.race([
+                new Promise((resolve) => {
+                    const stdin = process.stdin;
+                    stdin.setEncoding("utf-8");
+                    stdin.once("data", (data) => {
+                        resolve(data.toString().trim());
+                    });
+                }),
+                new Promise((_, reject) => {
+                    setTimeout(() => {
+                        reject(new TimeoutError("Input", timeoutMs));
+                    }, timeoutMs);
+                }),
+            ]);
+        }
+        catch (error) {
+            if (error instanceof TimeoutError) {
+                ConsoleUI.printError("Input timeout", "Please try again");
+            }
+            else {
+                ConsoleUI.printError("Failed to read input", "Please check your terminal configuration");
+            }
+            return null;
+        }
+    }
+    static async getConfirmation(message) {
+        console.log(`${message} (y/N): `);
+        const input = await this.getInput(10000);
+        if (!input) {
+            return false;
+        }
+        return ["y", "yes", "yeah", "yep"].includes(input.toLowerCase());
+    }
+    static async promptLocation() {
+        console.log("\nSelect settings location:");
+        console.log("  1. User settings (global)");
+        console.log("  2. Workspace settings (project-specific)");
+        console.log("\nChoice (1 or 2): ");
+        const input = await this.getInput(10000);
+        if (input === "2") {
+            return "workspace";
+        }
+        return "user";
+    }
+}
+async function viewCurrentConfiguration() {
+    ConsoleUI.clear();
+    ConsoleUI.printBanner();
+    const location = await InputHandler.promptLocation();
+    const buttons = SettingsManager.getButtons(location);
+    const debugMode = SettingsManager.getDebugMode(location);
+    ConsoleUI.printDivider();
+    console.log(`Configuration (${location} settings)`);
+    ConsoleUI.printDivider();
+    console.log();
+    console.log(`Debug Mode: ${debugMode ? "✅ Enabled" : "❌ Disabled"}`);
+    console.log(`Total Buttons: ${buttons.length}`);
+    console.log();
+    if (buttons.length === 0) {
+        ConsoleUI.printWarning("No buttons configured");
+        return;
+    }
+    ConsoleUI.printDivider();
+    console.log("Buttons:");
+    ConsoleUI.printDivider();
+    const rows = buttons.map((btn, idx) => [
+        `${idx + 1}`,
+        btn.id,
+        btn.text,
+        btn.command.type,
+        btn.enabled === false ? "❌" : "✅",
+    ]);
+    ConsoleUI.printTable(["#", "ID", "Text", "Type", "Enabled"], rows);
+}
+async function applyPreset() {
+    ConsoleUI.clear();
+    ConsoleUI.printBanner();
+    console.log("Available Presets:");
+    ConsoleUI.printDivider();
+    const presetKeys = Object.keys(BUILTIN_PRESETS);
+    presetKeys.forEach((key, idx) => {
+        const preset = BUILTIN_PRESETS[key];
+        console.log(`  ${idx + 1}. ${preset.name}`);
+        console.log(`     ${CONFIG.colors.dim}${preset.description}${CONFIG.colors.reset}`);
+        console.log(`     ${CONFIG.colors.dim}${preset.buttons.length} buttons${CONFIG.colors.reset}`);
+        console.log();
+    });
+    console.log("Select preset (1-" + presetKeys.length + "): ");
+    const input = await InputHandler.getInput(10000);
+    if (!input) {
+        ConsoleUI.printWarning("Operation cancelled");
+        return;
+    }
+    const index = parseInt(input, 10) - 1;
+    if (index < 0 || index >= presetKeys.length) {
+        ConsoleUI.printError("Invalid selection");
+        return;
+    }
+    const presetKey = presetKeys[index];
+    const preset = BUILTIN_PRESETS[presetKey];
+    ConsoleUI.printInfo(`Selected: ${preset.name}`);
+    const location = await InputHandler.promptLocation();
+    const existingButtons = SettingsManager.getButtons(location);
+    if (existingButtons.length > 0) {
+        console.log("\nMerge mode:");
+        console.log("  1. Replace all (removes existing buttons)");
+        console.log("  2. Append (adds to existing buttons)");
+        console.log("  3. Merge (replaces buttons with same ID)");
+        console.log("\nChoice (1-3): ");
+        const mergeInput = await InputHandler.getInput(10000);
+        let buttons = [];
+        switch (mergeInput) {
+            case "1":
+                buttons = preset.buttons;
+                break;
+            case "2":
+                buttons = [...existingButtons, ...preset.buttons];
+                break;
+            case "3": {
+                const mergedMap = new Map(existingButtons.map((b) => [b.id, b]));
+                preset.buttons.forEach((b) => mergedMap.set(b.id, b));
+                buttons = Array.from(mergedMap.values());
+                break;
+            }
+            default:
+                ConsoleUI.printWarning("Invalid choice, operation cancelled");
+                return;
+        }
+        SettingsManager.setButtons(location, buttons);
+    }
+    else {
+        SettingsManager.setButtons(location, preset.buttons);
+    }
+    ConsoleUI.printSuccess(`Preset "${preset.name}" applied to ${location} settings`);
+}
+async function addButton() {
+    ConsoleUI.clear();
+    ConsoleUI.printBanner();
+    const location = await InputHandler.promptLocation();
+    console.log("Button ID (unique identifier): ");
+    const id = await InputHandler.getInput(10000);
+    if (!id) {
+        ConsoleUI.printWarning("Operation cancelled");
+        return;
+    }
+    console.log("Button text (what shows on status bar): ");
+    const text = await InputHandler.getInput(10000);
+    if (!text) {
+        ConsoleUI.printWarning("Operation cancelled");
+        return;
+    }
+    console.log("Tooltip (hover text): ");
+    const tooltip = (await InputHandler.getInput(10000)) || text;
+    console.log("\nCommand type:");
+    console.log("  1. npm    2. yarn    3. pnpm    4. bun");
+    console.log("  5. shell  6. vscode  7. task    8. detect");
+    console.log("\nChoice (1-8): ");
+    const typeInput = await InputHandler.getInput(10000);
+    const typeMap = {
+        "1": "npm",
+        "2": "yarn",
+        "3": "pnpm",
+        "4": "bun",
+        "5": "shell",
+        "6": "vscode",
+        "7": "task",
+        "8": "detect",
+    };
+    const commandType = typeMap[typeInput || ""] || "shell";
+    console.log(`\n${commandType === "shell" || commandType === "vscode" || commandType === "task" ? "Command" : "Script name"}: `);
+    const commandValue = await InputHandler.getInput(10000);
+    if (!commandValue) {
+        ConsoleUI.printWarning("Operation cancelled");
+        return;
+    }
+    const button = {
+        id,
+        text,
+        tooltip,
+        command: commandType === "shell" ||
+            commandType === "vscode" ||
+            commandType === "task"
+            ? {
+                type: commandType,
+                command: commandValue,
+            }
+            : {
+                type: commandType,
+                script: commandValue,
+            },
+        enabled: true,
+        alignment: "left",
+        priority: 100,
+    };
+    const buttons = SettingsManager.getButtons(location);
+    buttons.push(button);
+    SettingsManager.setButtons(location, buttons);
+    ConsoleUI.printSuccess(`Button "${text}" added to ${location} settings`);
+}
+async function removeButton() {
+    ConsoleUI.clear();
+    ConsoleUI.printBanner();
+    const location = await InputHandler.promptLocation();
+    const buttons = SettingsManager.getButtons(location);
+    if (buttons.length === 0) {
+        ConsoleUI.printWarning("No buttons to remove");
+        return;
+    }
+    console.log("Select button to remove:");
+    ConsoleUI.printDivider();
+    buttons.forEach((btn, idx) => {
+        console.log(`  ${idx + 1}. ${btn.text} (${btn.id})`);
+    });
+    console.log(`\nChoice (1-${buttons.length}): `);
+    const input = await InputHandler.getInput(10000);
+    if (!input) {
+        ConsoleUI.printWarning("Operation cancelled");
+        return;
+    }
+    const index = parseInt(input, 10) - 1;
+    if (index < 0 || index >= buttons.length) {
+        ConsoleUI.printError("Invalid selection");
+        return;
+    }
+    const removedButton = buttons[index];
+    buttons.splice(index, 1);
+    SettingsManager.setButtons(location, buttons);
+    ConsoleUI.printSuccess(`Button "${removedButton.text}" removed from ${location} settings`);
+}
+async function toggleDebugMode() {
+    ConsoleUI.clear();
+    ConsoleUI.printBanner();
+    const location = await InputHandler.promptLocation();
+    const currentDebugMode = SettingsManager.getDebugMode(location);
+    ConsoleUI.printInfo(`Debug mode is currently ${currentDebugMode ? "enabled" : "disabled"}`);
+    const confirmed = await InputHandler.getConfirmation(`${currentDebugMode ? "Disable" : "Enable"} debug mode?`);
+    if (!confirmed) {
+        ConsoleUI.printWarning("Operation cancelled");
+        return;
+    }
+    SettingsManager.setDebugMode(location, !currentDebugMode);
+    ConsoleUI.printSuccess(`Debug mode ${!currentDebugMode ? "enabled" : "disabled"} in ${location} settings`);
+}
+async function exportConfiguration() {
+    ConsoleUI.clear();
+    ConsoleUI.printBanner();
+    const location = await InputHandler.promptLocation();
+    const buttons = SettingsManager.getButtons(location);
+    console.log("Export file path (e.g., config.json): ");
+    const filePath = await InputHandler.getInput(10000);
+    if (!filePath) {
+        ConsoleUI.printWarning("Operation cancelled");
+        return;
+    }
+    const exportData = {
+        buttons,
+        history: true,
+        autoDetect: false,
+        settings: {
+            debug: SettingsManager.getDebugMode(location),
+        },
+    };
+    try {
+        (0, fs_1.writeFileSync)(filePath, JSON.stringify(exportData, null, 2), "utf-8");
+        ConsoleUI.printSuccess(`Configuration exported to ${filePath}`);
+    }
+    catch (error) {
+        ConsoleUI.printError(`Failed to export: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function importConfiguration() {
+    ConsoleUI.clear();
+    ConsoleUI.printBanner();
+    console.log("Import file path: ");
+    const filePath = await InputHandler.getInput(10000);
+    if (!filePath) {
+        ConsoleUI.printWarning("Operation cancelled");
+        return;
+    }
+    if (!(0, fs_1.existsSync)(filePath)) {
+        ConsoleUI.printError("File not found");
+        return;
+    }
+    try {
+        const content = (0, fs_1.readFileSync)(filePath, "utf-8");
+        const importedConfig = JSON.parse(content);
+        if (!importedConfig.buttons || !Array.isArray(importedConfig.buttons)) {
+            ConsoleUI.printError("Invalid configuration file");
+            return;
+        }
+        const location = await InputHandler.promptLocation();
+        const existingButtons = SettingsManager.getButtons(location);
+        if (existingButtons.length > 0) {
+            console.log("\nImport mode:");
+            console.log("  1. Replace all");
+            console.log("  2. Merge");
+            console.log("\nChoice (1-2): ");
+            const mergeInput = await InputHandler.getInput(10000);
+            if (mergeInput === "2") {
+                const mergedButtons = [...existingButtons, ...importedConfig.buttons];
+                SettingsManager.setButtons(location, mergedButtons);
+            }
+            else {
+                SettingsManager.setButtons(location, importedConfig.buttons);
+            }
+        }
+        else {
+            SettingsManager.setButtons(location, importedConfig.buttons);
+        }
+        ConsoleUI.printSuccess(`Configuration imported to ${location} settings (${importedConfig.buttons.length} buttons)`);
+    }
+    catch (error) {
+        ConsoleUI.printError(`Failed to import: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function resetToDefaults() {
+    ConsoleUI.clear();
+    ConsoleUI.printBanner();
+    const location = await InputHandler.promptLocation();
+    const confirmed = await InputHandler.getConfirmation(`Reset ${location} settings to defaults? This will remove all buttons.`);
+    if (!confirmed) {
+        ConsoleUI.printWarning("Operation cancelled");
+        return;
+    }
+    SettingsManager.setButtons(location, []);
+    SettingsManager.setDebugMode(location, false);
+    ConsoleUI.printSuccess(`${location} settings reset to defaults`);
+}
+async function showHelp() {
+    ConsoleUI.clear();
+    ConsoleUI.printBanner();
+    ConsoleUI.printDivider();
+    console.log("Help & Usage Guide");
+    ConsoleUI.printDivider();
+    console.log();
+    console.log("Available Operations:");
+    ConsoleUI.printDivider();
+    for (const option of MENU_OPTIONS) {
+        console.log(`  ${option.key}. ${option.label}`);
+        console.log(`     ${option.description}`);
+        if (option.requiresConfirmation) {
+            ConsoleUI.printWarning("     Requires confirmation");
+        }
+        console.log();
+    }
+    ConsoleUI.printDivider();
+    console.log("Settings Locations:");
+    ConsoleUI.printDivider();
+    console.log("  • User settings: Global settings for all workspaces");
+    console.log("  • Workspace settings: Project-specific settings");
+    console.log();
+    ConsoleUI.printDivider();
+    console.log("Built-in Presets:");
+    ConsoleUI.printDivider();
+    Object.values(BUILTIN_PRESETS).forEach((preset) => {
+        console.log(`  • ${preset.name}: ${preset.description}`);
+    });
+    console.log();
+    ConsoleUI.printDivider();
+}
+class ConfigCLI {
+    state = {
+        isRunning: true,
+        operationCount: 0,
+        startTime: Date.now(),
+    };
+    async run() {
+        ConsoleUI.clear();
+        ConsoleUI.printBanner();
+        try {
+            while (this.state.isRunning) {
+                this.displayMainMenu();
+                const input = await InputHandler.getInput();
+                if (!input) {
+                    this.handleQuit("Input timeout");
+                    break;
+                }
+                await this.processInput(input);
+            }
+        }
+        catch (error) {
+            this.handleError(error);
+            this.state.isRunning = false;
+        }
+    }
+    displayMainMenu() {
+        ConsoleUI.printMenu();
+    }
+    async processInput(input) {
+        const validation = InputValidator.validateChoice(input);
+        if (!validation.isValid) {
+            if (validation.value === "quit") {
+                this.handleQuit("User requested exit");
+                return;
+            }
+            ConsoleUI.printError(validation.error, validation.suggestion);
+            console.log("Press Enter to try again...");
+            await InputHandler.getInput(10000);
+            ConsoleUI.clear();
+            ConsoleUI.printBanner();
+            return;
+        }
+        await this.executeChoice(validation.value);
+        if (!["1", "9"].includes(validation.value)) {
+            console.log("\nPress Enter to return to menu...");
+            await InputHandler.getInput(15000);
+        }
+        ConsoleUI.clear();
+        ConsoleUI.printBanner();
+    }
+    async executeChoice(choice) {
+        const option = MENU_OPTIONS.find((opt) => opt.key === choice);
+        if (!option) {
+            ConsoleUI.printError("Invalid option selected");
+            return;
+        }
+        if (option.requiresConfirmation) {
+            const confirmed = await InputHandler.getConfirmation(`Are you sure you want to ${option.label.toLowerCase()}?`);
+            if (!confirmed) {
+                ConsoleUI.printWarning(`${option.label} cancelled`);
+                return;
+            }
+        }
+        try {
+            this.state.operationCount++;
+            await option.action();
+        }
+        catch (error) {
+            ConsoleUI.printError(`${option.label} operation failed`, error instanceof ConfigCLIError ? error.suggestion : "Please try again");
+        }
+    }
+    handleQuit(reason) {
+        const duration = Date.now() - this.state.startTime;
+        const message = reason ? `${reason}. ` : "";
+        ConsoleUI.clear();
+        ConsoleUI.printBanner();
+        ConsoleUI.printSuccess(`${message}Thank you for using Config CLI! Operations: ${this.state.operationCount}, Duration: ${Math.round(duration)}ms`);
+        this.state.isRunning = false;
+    }
+    handleError(error) {
+        ConsoleUI.clear();
+        ConsoleUI.printBanner();
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        const errorCode = error instanceof ConfigCLIError ? error.code : "UNKNOWN_ERROR";
+        ConsoleUI.printError(`An unexpected error occurred: ${errorMessage}`, "Please report this issue with the error code below");
+        console.log(`Error Code: ${errorCode}`);
+        console.log(`Timestamp: ${new Date().toISOString()}`);
+        ConsoleUI.printDivider();
+    }
+}
+async function main() {
+    try {
+        const cli = new ConfigCLI();
+        await cli.run();
+    }
+    catch (error) {
+        console.error("Failed to start application:", error);
+        process.exit(1);
+    }
+}
+process.on("unhandledRejection", (reason, promise) => {
+    console.error("Unhandled Rejection at:", promise, "reason:", reason);
+    console.error("This might be due to an unhandled async operation");
+    process.exit(1);
+});
+process.on("uncaughtException", (error) => {
+    console.error("Uncaught Exception:", error);
+    console.error("The application encountered a critical error and must exit");
+    process.exit(1);
+});
+process.on("SIGINT", () => {
+    ConsoleUI.printWarning("Received interrupt signal. Shutting down gracefully...");
+    process.exit(0);
+});
+main().catch((error) => {
+    console.error("Fatal error during application startup:", error);
+    process.exit(1);
+});