Skip to content

A native macOS / windows / Linux database IDE built with Swift and AppKit. Connect to PostgreSQL, MySQL, SQLite, and Redis from a single app with a fast, keyboard-driven interface.

C++
12.5 KB
Raw Blame
// SettingsView.swift
// Gridex
//
// Settings window using SwiftUI.

import SwiftUI

struct SettingsView: View {
    var body: some View {
        TabView {
            GeneralSettingsView()
                .tabItem {
                    Label("General", systemImage: "gear")
                }

            AISettingsView()
                .tabItem {
                    Label("AI", systemImage: "brain")
                }

            EditorSettingsView()
                .tabItem {
                    Label("Editor", systemImage: "pencil")
                }
        }
        .frame(width: 580, height: 420)
    }
}

struct GeneralSettingsView: View {
    @AppStorage("general.pageSize") private var pageSize = 300
    @AppStorage("general.confirmBeforeDelete") private var confirmBeforeDelete = true
    @AppStorage("general.autoRefreshSidebar") private var autoRefreshSidebar = true
    @AppStorage("general.refreshInterval") private var refreshInterval = 300 // seconds
    @AppStorage("general.showQueryLog") private var showQueryLog = false
    @AppStorage("mcp.hideStatusBarIcon") private var hideStatusBarIcon = false
    @AppStorage("redis.keyBrowser.delimiter") private var redisKeyBrowserDelimiter = ":"

    var body: some View {
        Form {
            Section("Data Grid") {
                Picker("Default page size", selection: $pageSize) {
                    Text("100").tag(100)
                    Text("300").tag(300)
                    Text("500").tag(500)
                    Text("1000").tag(1000)
                }
                Toggle("Confirm before deleting rows", isOn: $confirmBeforeDelete)
            }

            Section("Sidebar") {
                Toggle("Auto-refresh schema", isOn: $autoRefreshSidebar)
                if autoRefreshSidebar {
                    Picker("Refresh interval", selection: $refreshInterval) {
                        Text("1 minute").tag(60)
                        Text("5 minutes").tag(300)
                        Text("15 minutes").tag(900)
                        Text("Never").tag(0)
                    }
                }
            }

            Section("Redis") {
                TextField("Key namespace delimiter", text: $redisKeyBrowserDelimiter)
                    .onSubmit(normalizeRedisKeyBrowserDelimiter)
                Text("Keys are grouped by this delimiter in the sidebar.")
                    .font(.system(size: 11))
                    .foregroundStyle(.secondary)
            }

            Section("Query") {
                Toggle("Show query log panel by default", isOn: $showQueryLog)
            }

            Section("Status Bar") {
                Toggle("Hide status bar icon", isOn: $hideStatusBarIcon)
            }
        }
        .formStyle(.grouped)
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .onChange(of: hideStatusBarIcon) { _, _ in
            Task { @MainActor in
                MCPStatusBarController.shared.refresh()
            }
        }
        .onDisappear(perform: normalizeRedisKeyBrowserDelimiter)
    }

    private func normalizeRedisKeyBrowserDelimiter() {
        redisKeyBrowserDelimiter = RedisKeyBrowserBehavior.effectiveDelimiter(
            for: redisKeyBrowserDelimiter
        )
    }
}

struct AISettingsView: View {
    private let keychain: KeychainServiceProtocol = DependencyContainer.shared.keychainService
    private let repository: any LLMProviderRepository = DependencyContainer.shared.llmProviderRepository

    @AppStorage("ai.activeProviderID") private var activeProviderID: String = ""

    @State private var providers: [ProviderConfig] = []
    @State private var editing: EditingTarget?
    @State private var loadError: String?

    private enum EditingTarget: Identifiable {
        case add
        case edit(ProviderConfig)

        var id: String {
            switch self {
            case .add:            return "__add__"
            case .edit(let c):    return c.id.uuidString
            }
        }
    }

    var body: some View {
        VStack(spacing: 0) {
            activeSection
            Divider()
            providersList
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .onAppear(perform: reload)
        .sheet(item: $editing) { target in
            switch target {
            case .add:
                ProviderEditSheet(editing: nil) { _ in reload() }
            case .edit(let config):
                ProviderEditSheet(editing: config) { _ in reload() }
            }
        }
    }

    // MARK: - Active picker

    private var activeSection: some View {
        Form {
            Section("Active Provider") {
                if enabledProviders.isEmpty {
                    Text("No provider configured yet. Click + to add one.")
                        .foregroundStyle(.secondary)
                        .font(.system(size: 12))
                } else {
                    Picker("Used by AI chat", selection: $activeProviderID) {
                        ForEach(enabledProviders) { p in
                            Label("\(p.name) — \(p.type.displayName)", systemImage: p.type.iconName)
                                .tag(p.id.uuidString)
                        }
                    }
                }
            }
        }
        .formStyle(.grouped)
        .frame(height: 100)
    }

    // MARK: - Providers list

    private var providersList: some View {
        VStack(spacing: 0) {
            HStack {
                Text("Providers").font(.headline)
                Spacer()
                Button(action: { editing = .add }) {
                    Label("Add Provider", systemImage: "plus")
                }
            }
            .padding(.horizontal, 20)
            .padding(.top, 12)
            .padding(.bottom, 8)

            if providers.isEmpty {
                VStack(spacing: 8) {
                    Image(systemName: "brain")
                        .font(.system(size: 32))
                        .foregroundStyle(.secondary)
                    Text("No providers yet")
                        .foregroundStyle(.secondary)
                    Text("Add Anthropic, OpenAI, Gemini, Ollama, Groq, DeepSeek and more.")
                        .font(.system(size: 11))
                        .foregroundStyle(.tertiary)
                }
                .frame(maxWidth: .infinity, maxHeight: .infinity)
            } else {
                List {
                    ForEach(providers) { p in
                        providerRow(p)
                    }
                }
                .listStyle(.inset(alternatesRowBackgrounds: true))
            }

            if let loadError {
                Text(loadError)
                    .font(.system(size: 11))
                    .foregroundStyle(.red)
                    .padding(.horizontal, 20)
                    .padding(.bottom, 8)
            }
        }
    }

    private func providerRow(_ p: ProviderConfig) -> some View {
        HStack(spacing: 10) {
            Image(systemName: p.type.iconName)
                .font(.system(size: 16))
                .foregroundStyle(.tint)
                .frame(width: 24)

            VStack(alignment: .leading, spacing: 2) {
                HStack(spacing: 6) {
                    Text(p.name).font(.system(size: 13, weight: .medium))
                    if p.id.uuidString == activeProviderID {
                        Text("ACTIVE")
                            .font(.system(size: 9, weight: .bold))
                            .padding(.horizontal, 5).padding(.vertical, 1)
                            .background(Color.accentColor.opacity(0.18))
                            .foregroundStyle(.tint)
                            .clipShape(RoundedRectangle(cornerRadius: 3))
                    }
                }
                Text("\(p.type.displayName) · \(p.model)")
                    .font(.system(size: 11))
                    .foregroundStyle(.secondary)
            }

            Spacer()

            Toggle("", isOn: Binding(
                get: { p.enabled },
                set: { toggleEnabled(p, $0) }
            ))
            .labelsHidden()
            .toggleStyle(.switch)
            .controlSize(.small)

            Button(action: { editing = .edit(p) }) {
                Image(systemName: "pencil")
            }
            .buttonStyle(.plain)
            .help("Edit")

            Button(action: { delete(p) }) {
                Image(systemName: "trash")
            }
            .buttonStyle(.plain)
            .foregroundStyle(.red)
            .help("Delete")
        }
        .padding(.vertical, 4)
    }

    // MARK: - Data

    private var enabledProviders: [ProviderConfig] {
        providers.filter(\.enabled)
    }

    private func reload() {
        Task {
            do {
                let list = try await repository.fetchAll()
                await MainActor.run {
                    providers = list
                    loadError = nil
                    // Ensure activeProviderID points at a valid enabled entry
                    if !list.contains(where: { $0.id.uuidString == activeProviderID && $0.enabled }),
                       let first = list.first(where: { $0.enabled }) {
                        activeProviderID = first.id.uuidString
                    }
                }
            } catch {
                await MainActor.run { loadError = error.localizedDescription }
            }
        }
    }

    private func toggleEnabled(_ p: ProviderConfig, _ enabled: Bool) {
        var updated = p
        updated.enabled = enabled
        Task {
            try? await repository.update(updated)
            let apiKey = (try? keychain.load(key: ProviderEditSheet.keychainKey(id: p.id))) ?? ""
            if enabled {
                // Pass the OAuth service unconditionally — non-ChatGPT factory
                // branches ignore it, ChatGPT requires it (otherwise the
                // factory hits preconditionFailure when re-enabling a
                // ChatGPT provider).
                await DependencyContainer.shared.providerRegistry.register(
                    updated,
                    apiKey: apiKey,
                    chatGPTOAuthService: DependencyContainer.shared.chatGPTOAuthService
                )
            } else {
                await DependencyContainer.shared.providerRegistry.unregister(updated.name)
            }
            await MainActor.run { reload() }
        }
    }

    private func delete(_ p: ProviderConfig) {
        Task {
            try? await repository.delete(p.id)
            // Clean up both credential variants — only one is set in practice,
            // but deleting both is cheap and avoids leaks if the type was ever
            // changed from API-key to ChatGPT (or vice versa) for the same id.
            try? keychain.delete(key: ProviderEditSheet.keychainKey(id: p.id))
            try? keychain.deleteChatGPTTokens(providerId: p.id)
            await DependencyContainer.shared.providerRegistry.unregister(p.name)
            await MainActor.run { reload() }
        }
    }
}

struct EditorSettingsView: View {
    @AppStorage("editor.fontSize") private var fontSize = 12.0
    @AppStorage("editor.tabSize") private var tabSize = 4
    @AppStorage("editor.useSpaces") private var useSpaces = true
    @AppStorage("editor.wordWrap") private var wordWrap = false
    @AppStorage("editor.showLineNumbers") private var showLineNumbers = true
    @AppStorage("editor.highlightCurrentLine") private var highlightCurrentLine = true

    var body: some View {
        Form {
            Section("Font") {
                HStack {
                    Text("Font size")
                    Spacer()
                    TextField("", value: $fontSize, format: .number)
                        .frame(width: 50)
                        .textFieldStyle(.roundedBorder)
                    Stepper("", value: $fontSize, in: 8...24, step: 1)
                        .labelsHidden()
                }
            }

            Section("Indentation") {
                Picker("Tab size", selection: $tabSize) {
                    Text("2 spaces").tag(2)
                    Text("4 spaces").tag(4)
                    Text("8 spaces").tag(8)
                }
                Toggle("Use spaces instead of tabs", isOn: $useSpaces)
            }

            Section("Display") {
                Toggle("Word wrap", isOn: $wordWrap)
                Toggle("Show line numbers", isOn: $showLineNumbers)
                Toggle("Highlight current line", isOn: $highlightCurrentLine)
            }
        }
        .formStyle(.grouped)
        .frame(maxWidth: .infinity, maxHeight: .infinity)
    }
}