@sriinnu/runic 2.0.0 → 2.11.1

package/Sources/Runic/Views/Preferences/PreferencesAdvancedPane.swift

@@ -1,268 +0,0 @@
-import AppKit
-import KeyboardShortcuts
-import RunicCore
-import SwiftUI
-
-@MainActor
-struct AdvancedPane: View {
-    @Bindable var settings: SettingsStore
-    @Bindable var store: UsageStore
-    @State private var isInstallingCLI = false
-    @State private var cliStatus: String?
-
-    var body: some View {
-        PreferencesPane {
-            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
-                Text("Refresh cadence")
-                    .font(RunicFont.caption)
-                    .foregroundStyle(.secondary)
-                    .textCase(.uppercase)
-                Picker("", selection: self.$settings.refreshFrequency) {
-                    ForEach(RefreshFrequency.allCases) { option in
-                        Text(option.label).tag(option)
-                    }
-                }
-                .pickerStyle(.segmented)
-
-                if self.settings.refreshFrequency == .manual {
-                    Text("Auto-refresh is off; use the menu's Refresh command.")
-                        .font(RunicFont.footnote)
-                        .foregroundStyle(.secondary)
-                }
-                if let badgeText = self.store.autoRefreshDisableBadgeText() {
-                    Text(badgeText)
-                        .font(RunicFont.caption2.weight(.medium))
-                        .padding(.horizontal, RunicSpacing.xs)
-                        .padding(.vertical, RunicSpacing.xxs)
-                        .background(Color(nsColor: .controlBackgroundColor))
-                        .clipShape(Capsule())
-                        .foregroundStyle(.secondary)
-                }
-                Text("Auto-refresh can switch to Manual when your Mac is idle or sleeps/locks. Adjust below.")
-                    .font(RunicFont.footnote)
-                    .foregroundStyle(.secondary)
-            }
-
-            PreferencesDivider()
-
-            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
-                Text("Auto-refresh safety")
-                    .font(RunicFont.caption)
-                    .foregroundStyle(.secondary)
-                    .textCase(.uppercase)
-
-                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                    Toggle(isOn: self.$settings.autoDisableRefreshWhenIdleEnabled) {
-                        Text("Switch to Manual when idle")
-                            .font(RunicFont.body)
-                    }
-                    .toggleStyle(.checkbox)
-
-                    Text("If your Mac is idle for the threshold below, Runic switches auto-refresh to Manual.")
-                        .font(RunicFont.footnote)
-                        .foregroundStyle(.tertiary)
-                        .fixedSize(horizontal: false, vertical: true)
-
-                    PreferenceStepperRow(
-                        title: "Idle threshold",
-                        subtitle: nil,
-                        step: 1,
-                        range: 1...60,
-                        valueLabel: { "\($0) min" },
-                        value: self.$settings.autoDisableRefreshWhenIdleMinutes)
-                        .disabled(!self.settings.autoDisableRefreshWhenIdleEnabled)
-                        .opacity(self.settings.autoDisableRefreshWhenIdleEnabled ? 1 : 0.5)
-                }
-
-                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                    Toggle(isOn: self.$settings.autoDisableRefreshOnSleepEnabled) {
-                        Text("Switch to Manual on sleep/lock")
-                            .font(RunicFont.body)
-                    }
-                    .toggleStyle(.checkbox)
-
-                    Text("When your Mac sleeps or locks, auto-refresh moves to Manual to avoid background checks.")
-                        .font(RunicFont.footnote)
-                        .foregroundStyle(.tertiary)
-                        .fixedSize(horizontal: false, vertical: true)
-                }
-
-                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                    Toggle(isOn: self.$settings.autoRefreshWarningEnabled) {
-                        Text("Warn after repeated auto-refreshes")
-                            .font(RunicFont.body)
-                    }
-                    .toggleStyle(.checkbox)
-
-                    Text("Sends a notification after the configured number of auto-refresh cycles.")
-                        .font(RunicFont.footnote)
-                        .foregroundStyle(.tertiary)
-                        .fixedSize(horizontal: false, vertical: true)
-
-                    PreferenceStepperRow(
-                        title: "Warning threshold",
-                        subtitle: nil,
-                        step: 1,
-                        range: 5...100,
-                        valueLabel: { "\($0) runs" },
-                        value: self.$settings.autoRefreshWarningThreshold)
-                        .disabled(!self.settings.autoRefreshWarningEnabled)
-                        .opacity(self.settings.autoRefreshWarningEnabled ? 1 : 0.5)
-                }
-
-                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                    Toggle(isOn: self.$settings.autoSuspendInactiveProvidersEnabled) {
-                        Text("Skip inactive providers")
-                            .font(RunicFont.body)
-                    }
-                    .toggleStyle(.checkbox)
-
-                    Text("Pauses auto-refresh for providers with no usage changes for the threshold below.")
-                        .font(RunicFont.footnote)
-                        .foregroundStyle(.tertiary)
-                        .fixedSize(horizontal: false, vertical: true)
-
-                    PreferenceStepperRow(
-                        title: "Inactive threshold",
-                        subtitle: nil,
-                        step: 30,
-                        range: 30...10080,
-                        valueLabel: { Self.inactiveThresholdLabel(for: $0) },
-                        value: self.$settings.autoSuspendInactiveProvidersMinutes)
-                        .disabled(!self.settings.autoSuspendInactiveProvidersEnabled)
-                        .opacity(self.settings.autoSuspendInactiveProvidersEnabled ? 1 : 0.5)
-                }
-
-                Text("Auto-refresh can read local logs or browser cookies depending on provider settings.")
-                    .font(RunicFont.footnote)
-                    .foregroundStyle(.tertiary)
-                    .fixedSize(horizontal: false, vertical: true)
-                Text("Auto-refresh also switches to Manual when your Mac sleeps or is locked.")
-                    .font(RunicFont.footnote)
-                    .foregroundStyle(.tertiary)
-                    .fixedSize(horizontal: false, vertical: true)
-            }
-
-            PreferencesDivider()
-
-            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
-                Text("Keyboard shortcut")
-                    .font(RunicFont.caption)
-                    .foregroundStyle(.secondary)
-                    .textCase(.uppercase)
-                HStack(alignment: .center, spacing: RunicSpacing.sm) {
-                    Text("Open menu")
-                        .font(RunicFont.body)
-                    Spacer()
-                    KeyboardShortcuts.Recorder(for: .openMenu)
-                }
-                Text("Trigger the menu bar menu from anywhere.")
-                    .font(RunicFont.footnote)
-                    .foregroundStyle(.tertiary)
-            }
-
-            PreferencesDivider()
-
-            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
-                HStack(spacing: RunicSpacing.sm) {
-                    Button {
-                        Task { await self.installCLI() }
-                    } label: {
-                        if self.isInstallingCLI {
-                            ProgressView().controlSize(.small)
-                        } else {
-                            Text("Install CLI")
-                        }
-                    }
-                    .disabled(self.isInstallingCLI)
-
-                    if let status = self.cliStatus {
-                        Text(status)
-                            .font(RunicFont.footnote)
-                            .foregroundStyle(.tertiary)
-                            .lineLimit(2)
-                    }
-                }
-                Text("Symlink RunicCLI to /usr/local/bin and /opt/homebrew/bin as runic.")
-                    .font(RunicFont.footnote)
-                    .foregroundStyle(.tertiary)
-            }
-
-            PreferencesDivider()
-
-            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
-                PreferenceToggleRow(
-                    title: "Show Debug Settings",
-                    subtitle: "Expose troubleshooting tools in the Debug tab.",
-                    binding: self.$settings.debugMenuEnabled)
-            }
-        }
-    }
-
-    private static func inactiveThresholdLabel(for minutes: Int) -> String {
-        let inactiveMinutes = max(1, minutes)
-        if inactiveMinutes % 60 == 0 {
-            return "\(inactiveMinutes / 60) hr"
-        }
-        return "\(inactiveMinutes) min"
-    }
-}
-
-extension AdvancedPane {
-    private func installCLI() async {
-        if self.isInstallingCLI { return }
-        self.isInstallingCLI = true
-        defer { self.isInstallingCLI = false }
-
-        let helperURL = Bundle.main.bundleURL.appendingPathComponent("Contents/Helpers/RunicCLI")
-        let fm = FileManager.default
-        guard fm.fileExists(atPath: helperURL.path) else {
-            self.cliStatus = "RunicCLI not found in app bundle."
-            return
-        }
-
-        let destinations = [
-            "/usr/local/bin/runic",
-            "/opt/homebrew/bin/runic",
-        ]
-
-        var results: [String] = []
-        for dest in destinations {
-            let dir = (dest as NSString).deletingLastPathComponent
-            guard fm.fileExists(atPath: dir) else { continue }
-            guard fm.isWritableFile(atPath: dir) else {
-                results.append("No write access: \(dir)")
-                continue
-            }
-
-            if fm.fileExists(atPath: dest) {
-                if Self.isLink(atPath: dest, pointingTo: helperURL.path) {
-                    results.append("Installed: \(dir)")
-                } else {
-                    results.append("Exists: \(dir)")
-                }
-                continue
-            }
-
-            do {
-                try fm.createSymbolicLink(atPath: dest, withDestinationPath: helperURL.path)
-                results.append("Installed: \(dir)")
-            } catch {
-                results.append("Failed: \(dir)")
-            }
-        }
-
-        self.cliStatus = results.isEmpty
-            ? "No writable bin dirs found."
-            : results.joined(separator: " · ")
-    }
-
-    private static func isLink(atPath path: String, pointingTo destination: String) -> Bool {
-        guard let link = try? FileManager.default.destinationOfSymbolicLink(atPath: path) else { return false }
-        let dir = (path as NSString).deletingLastPathComponent
-        let resolved = URL(fileURLWithPath: link, relativeTo: URL(fileURLWithPath: dir))
-            .standardizedFileURL
-            .path
-        return resolved == destination
-    }
-}

package/Sources/Runic/Views/Preferences/PreferencesAlertsPane.swift

@@ -1,418 +0,0 @@
-import AppKit
-import RunicCore
-import SwiftUI
-
-@MainActor
-struct AlertsPane: View {
-    @Bindable var settings: SettingsStore
-    @Bindable var store: UsageStore
-
-    @State private var alertsData: AlertRuleStore.AlertsData = AlertRuleStore.load()
-    @State private var showingAddRule = false
-    @State private var editingRule: AlertRuleStore.AlertRule?
-    @State private var showingTestResult: String?
-    @State private var defaultWebhookURL: String = ""
-    @State private var webhookFormat: WebhookFormat = .slack
-
-    enum WebhookFormat: String, CaseIterable, Identifiable {
-        case slack
-        case discord
-        case generic
-
-        var id: String {
-            self.rawValue
-        }
-
-        var label: String {
-            switch self {
-            case .slack: "Slack"
-            case .discord: "Discord"
-            case .generic: "Generic"
-            }
-        }
-    }
-
-    var body: some View {
-        PreferencesPane {
-            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
-                Text("Alert Rules")
-                    .font(RunicFont.caption)
-                    .foregroundStyle(.secondary)
-                    .textCase(.uppercase)
-
-                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                    HStack {
-                        Text("\(self.alertsData.rules.count) rules configured")
-                            .font(RunicFont.footnote)
-                            .foregroundStyle(.secondary)
-
-                        Spacer()
-
-                        Button {
-                            self.showingAddRule = true
-                        } label: {
-                            Label("Add Rule", systemImage: "plus")
-                        }
-                        .buttonStyle(.bordered)
-                        .controlSize(.small)
-                    }
-
-                    if self.alertsData.rules.isEmpty {
-                        Text("No alert rules configured. Add a rule to get started.")
-                            .font(RunicFont.footnote)
-                            .foregroundStyle(.tertiary)
-                            .padding(.vertical, RunicSpacing.md)
-                            .frame(maxWidth: .infinity)
-                    } else {
-                        VStack(spacing: RunicSpacing.xxs) {
-                            ForEach(self.alertsData.rules) { rule in
-                                self.ruleRow(rule)
-                            }
-                        }
-                        .padding(.vertical, RunicSpacing.xs)
-                    }
-                }
-            }
-
-            PreferencesDivider()
-
-            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
-                Text("Webhook Configuration")
-                    .font(RunicFont.caption)
-                    .foregroundStyle(.secondary)
-                    .textCase(.uppercase)
-
-                VStack(alignment: .leading, spacing: RunicSpacing.sm) {
-                    VStack(alignment: .leading, spacing: 4) {
-                        Text("Default webhook URL")
-                            .font(RunicFont.body)
-                        TextField("https://hooks.slack.com/services/...", text: self.$defaultWebhookURL)
-                            .textFieldStyle(.roundedBorder)
-                        Text("Used for all alerts unless overridden in rule settings.")
-                            .font(RunicFont.footnote)
-                            .foregroundStyle(.tertiary)
-                    }
-
-                    VStack(alignment: .leading, spacing: 4) {
-                        Text("Webhook format")
-                            .font(RunicFont.body)
-                        Picker("", selection: self.$webhookFormat) {
-                            ForEach(WebhookFormat.allCases) { format in
-                                Text(format.label).tag(format)
-                            }
-                        }
-                        .pickerStyle(.segmented)
-                        .frame(maxWidth: 300)
-                    }
-
-                    HStack(spacing: RunicSpacing.xs) {
-                        Button("Test Webhook") {
-                            self.testWebhook()
-                        }
-                        .buttonStyle(.bordered)
-                        .disabled(self.defaultWebhookURL.isEmpty)
-
-                        if let result = self.showingTestResult {
-                            Text(result)
-                                .font(RunicFont.footnote)
-                                .foregroundStyle(result.contains("Success") ? .green : .red)
-                        }
-                    }
-                }
-            }
-
-            PreferencesDivider()
-
-            SettingsSection(contentSpacing: PreferencesLayoutMetrics.sectionSpacing) {
-                Text("Alert History")
-                    .font(RunicFont.caption)
-                    .foregroundStyle(.secondary)
-                    .textCase(.uppercase)
-
-                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                    HStack {
-                        Text("Last 20 triggered alerts")
-                            .font(RunicFont.footnote)
-                            .foregroundStyle(.secondary)
-
-                        Spacer()
-
-                        Button("Clear History") {
-                            self.clearHistory()
-                        }
-                        .buttonStyle(.bordered)
-                        .controlSize(.small)
-                        .disabled(self.alertsData.history.isEmpty)
-                    }
-
-                    let recentHistory = AlertRuleStore.getRecentHistory(limit: 20)
-
-                    if recentHistory.isEmpty {
-                        Text("No alerts triggered yet.")
-                            .font(RunicFont.footnote)
-                            .foregroundStyle(.tertiary)
-                            .padding(.vertical, RunicSpacing.md)
-                            .frame(maxWidth: .infinity)
-                    } else {
-                        ScrollView {
-                            VStack(spacing: RunicSpacing.xxs) {
-                                ForEach(recentHistory) { entry in
-                                    self.historyRow(entry)
-                                }
-                            }
-                        }
-                        .frame(maxHeight: 200)
-                    }
-                }
-            }
-        }
-        .sheet(isPresented: self.$showingAddRule) {
-            RuleEditorSheet(
-                rule: nil,
-                onSave: { newRule in
-                    do {
-                        try AlertRuleStore.addRule(newRule)
-                        self.alertsData = AlertRuleStore.load()
-                    } catch {
-                        print("Failed to add rule: \(error)")
-                    }
-                })
-        }
-        .sheet(item: self.$editingRule) { rule in
-            RuleEditorSheet(
-                rule: rule,
-                onSave: { updatedRule in
-                    do {
-                        try AlertRuleStore.updateRule(updatedRule)
-                        self.alertsData = AlertRuleStore.load()
-                    } catch {
-                        print("Failed to update rule: \(error)")
-                    }
-                })
-        }
-    }
-
-    private func ruleRow(_ rule: AlertRuleStore.AlertRule) -> some View {
-        HStack(spacing: RunicSpacing.sm) {
-            Toggle("", isOn: Binding(
-                get: { rule.enabled },
-                set: { enabled in
-                    var updatedRule = rule
-                    updatedRule.enabled = enabled
-                    try? AlertRuleStore.updateRule(updatedRule)
-                    self.alertsData = AlertRuleStore.load()
-                }))
-                .toggleStyle(.switch)
-                .controlSize(.small)
-
-            VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
-                HStack(spacing: RunicSpacing.xs) {
-                    Text(self.alertTypeLabel(rule.type))
-                        .font(RunicFont.body)
-
-                    self.severityBadge(rule.severity)
-                }
-
-                Text("Threshold: \(Int(rule.threshold))%")
-                    .font(RunicFont.footnote)
-                    .foregroundStyle(.secondary)
-            }
-
-            Spacer()
-
-            HStack(spacing: 4) {
-                Button {
-                    self.editingRule = rule
-                } label: {
-                    Image(systemName: "pencil")
-                }
-                .buttonStyle(.borderless)
-                .controlSize(.small)
-
-                Button {
-                    self.deleteRule(rule)
-                } label: {
-                    Image(systemName: "trash")
-                }
-                .buttonStyle(.borderless)
-                .controlSize(.small)
-                .foregroundStyle(.red)
-            }
-        }
-        .padding(RunicSpacing.xs)
-        .background(Color(nsColor: .controlBackgroundColor))
-        .cornerRadius(RunicCornerRadius.sm)
-    }
-
-    private func historyRow(_ entry: AlertRuleStore.AlertHistoryEntry) -> some View {
-        HStack(spacing: RunicSpacing.sm) {
-            self.severityBadge(entry.severity)
-
-            VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
-                Text(entry.message)
-                    .font(RunicFont.footnote)
-                    .lineLimit(2)
-
-                Text(self.relativeTime(entry.triggeredAt))
-                    .font(RunicFont.caption2)
-                    .foregroundStyle(.tertiary)
-            }
-
-            Spacer()
-
-            if !entry.acknowledged {
-                Button("Ack") {
-                    try? AlertRuleStore.acknowledgeAlert(id: entry.id)
-                    self.alertsData = AlertRuleStore.load()
-                }
-                .buttonStyle(.borderless)
-                .controlSize(.mini)
-                .foregroundStyle(.blue)
-            }
-        }
-        .padding(RunicSpacing.xs)
-        .background(Color(nsColor: .controlBackgroundColor).opacity(entry.acknowledged ? 0.5 : 1.0))
-        .cornerRadius(RunicCornerRadius.sm)
-    }
-
-    private func severityBadge(_ severity: AlertRuleStore.AlertSeverity) -> some View {
-        let color: Color = switch severity {
-        case .info: .blue
-        case .warning: .orange
-        case .critical: .red
-        }
-
-        return Text(severity.rawValue.uppercased())
-            .font(RunicFont.caption2.weight(.semibold))
-            .padding(.horizontal, RunicSpacing.xs)
-            .padding(.vertical, RunicSpacing.xxs)
-            .background(color.opacity(0.2))
-            .foregroundStyle(color)
-            .cornerRadius(RunicCornerRadius.xs)
-    }
-
-    private func alertTypeLabel(_ type: AlertRuleStore.AlertType) -> String {
-        switch type {
-        case .projectBudget: "Project Budget"
-        case .usageVelocity: "Usage Velocity"
-        case .costAnomaly: "Cost Anomaly"
-        case .quotaThreshold: "Quota Threshold"
-        }
-    }
-
-    private func relativeTime(_ date: Date) -> String {
-        let formatter = RelativeDateTimeFormatter()
-        formatter.unitsStyle = .abbreviated
-        return formatter.localizedString(for: date, relativeTo: Date())
-    }
-
-    private func deleteRule(_ rule: AlertRuleStore.AlertRule) {
-        try? AlertRuleStore.removeRule(id: rule.id)
-        self.alertsData = AlertRuleStore.load()
-    }
-
-    private func clearHistory() {
-        var data = self.alertsData
-        data.history = []
-        try? AlertRuleStore.save(data)
-        self.alertsData = AlertRuleStore.load()
-    }
-
-    private func testWebhook() {
-        guard !self.defaultWebhookURL.isEmpty else { return }
-
-        // Simulate webhook test
-        Task {
-            self.showingTestResult = "Testing..."
-            try? await Task.sleep(nanoseconds: 1_000_000_000)
-            self.showingTestResult = "Success: 200 OK"
-
-            try? await Task.sleep(nanoseconds: 3_000_000_000)
-            self.showingTestResult = nil
-        }
-    }
-}
-
-// MARK: - Rule Editor Sheet
-
-@MainActor
-private struct RuleEditorSheet: View {
-    @Environment(\.dismiss) private var dismiss
-
-    let rule: AlertRuleStore.AlertRule?
-    let onSave: (AlertRuleStore.AlertRule) -> Void
-
-    @State private var alertType: AlertRuleStore.AlertType
-    @State private var threshold: Double
-    @State private var severity: AlertRuleStore.AlertSeverity
-    @State private var webhookURL: String
-    @State private var notifyWebhook: Bool
-
-    init(rule: AlertRuleStore.AlertRule?, onSave: @escaping (AlertRuleStore.AlertRule) -> Void) {
-        self.rule = rule
-        self.onSave = onSave
-
-        self._alertType = State(initialValue: rule?.type ?? .projectBudget)
-        self._threshold = State(initialValue: rule?.threshold ?? 80.0)
-        self._severity = State(initialValue: rule?.severity ?? .warning)
-        self._webhookURL = State(initialValue: rule?.webhookURL ?? "")
-        self._notifyWebhook = State(initialValue: rule?.notifyWebhook ?? false)
-    }
-
-    var body: some View {
-        VStack(spacing: RunicSpacing.lg) {
-            Text(self.rule == nil ? "Add Alert Rule" : "Edit Alert Rule")
-                .font(RunicFont.headline)
-
-            Form {
-                Picker("Alert Type", selection: self.$alertType) {
-                    Text("Project Budget").tag(AlertRuleStore.AlertType.projectBudget)
-                    Text("Usage Velocity").tag(AlertRuleStore.AlertType.usageVelocity)
-                    Text("Cost Anomaly").tag(AlertRuleStore.AlertType.costAnomaly)
-                    Text("Quota Threshold").tag(AlertRuleStore.AlertType.quotaThreshold)
-                }
-
-                VStack(alignment: .leading, spacing: 4) {
-                    Text("Threshold: \(Int(self.threshold))%")
-                    Slider(value: self.$threshold, in: 0...100, step: 5)
-                }
-
-                Picker("Severity", selection: self.$severity) {
-                    Text("Info").tag(AlertRuleStore.AlertSeverity.info)
-                    Text("Warning").tag(AlertRuleStore.AlertSeverity.warning)
-                    Text("Critical").tag(AlertRuleStore.AlertSeverity.critical)
-                }
-
-                Toggle("Enable webhook notifications", isOn: self.$notifyWebhook)
-
-                if self.notifyWebhook {
-                    TextField("Webhook URL", text: self.$webhookURL)
-                }
-            }
-            .padding()
-
-            HStack {
-                Button("Cancel") {
-                    self.dismiss()
-                }
-                .keyboardShortcut(.cancelAction)
-
-                Button("Save") {
-                    let newRule = AlertRuleStore.AlertRule(
-                        id: self.rule?.id ?? UUID().uuidString,
-                        type: self.alertType,
-                        threshold: self.threshold,
-                        severity: self.severity,
-                        notifyWebhook: self.notifyWebhook,
-                        webhookURL: self.webhookURL.isEmpty ? nil : self.webhookURL,
-                        createdAt: self.rule?.createdAt ?? Date())
-                    self.onSave(newRule)
-                    self.dismiss()
-                }
-                .keyboardShortcut(.defaultAction)
-            }
-        }
-        .padding(RunicSpacing.lg)
-        .frame(width: 400)
-    }
-}