@sriinnu/runic 2.0.0 → 2.11.1

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

@@ -1,637 +0,0 @@
-import AppKit
-import RunicCore
-import SwiftUI
-
-@MainActor
-struct AnalyticsPane: View {
-    @Bindable var settings: SettingsStore
-    @Bindable var store: UsageStore
-
-    // MARK: - Disclosure state
-
-    @State private var displayExpanded = true
-    @State private var insightsExpanded = false
-    @State private var alertsExpanded = false
-    @State private var budgetsExpanded = false
-
-    // MARK: - Alerts state
-
-    @State private var alertsData: AlertRuleStore.AlertsData = AlertRuleStore.load()
-    @State private var showingAddRule = false
-    @State private var editingRule: AlertRuleStore.AlertRule?
-
-    // MARK: - Budgets state
-
-    @State private var budgets: [ProjectBudgetStore.ProjectBudget] = []
-    @State private var editingProjectID: String?
-    @State private var showingAddBudget = false
-    @State private var newProjectID = ""
-    @State private var newProjectName = ""
-    @State private var newMonthlyLimit = ""
-    @State private var newAlertThreshold = "80"
-    @State private var budgetErrorMessage: String?
-
-    @State private var appeared = false
-
-    var body: some View {
-        LiquidPreferencesPane {
-            // MARK: - Display section
-
-            DisclosureGroup("Display", isExpanded: self.$displayExpanded) {
-                VStack(alignment: .leading, spacing: PreferencesLayoutMetrics.sectionSpacing) {
-                    PreferenceToggleRow(
-                        title: "Show usage as used",
-                        subtitle: "Progress bars fill as you consume quota (instead of showing remaining).",
-                        binding: self.$settings.usageBarsShowUsed)
-                    VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                        Text("Usage metrics")
-                            .font(RunicFont.body)
-                        Picker("", selection: self.$settings.usageMetricDisplayMode) {
-                            ForEach(UsageMetricDisplayMode.allCases) { mode in
-                                Text(mode.label).tag(mode)
-                            }
-                        }
-                        .pickerStyle(.segmented)
-                        Text("Pick bars, percent, or both in the menu card.")
-                            .font(RunicFont.footnote)
-                            .foregroundStyle(.tertiary)
-                            .fixedSize(horizontal: false, vertical: true)
-                    }
-                    VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                        Text("Menu mode")
-                            .font(RunicFont.body)
-                        Picker("", selection: self.$settings.menuMode) {
-                            ForEach(MenuMode.allCases) { mode in
-                                Text(mode.label).tag(mode)
-                            }
-                        }
-                        .pickerStyle(.segmented)
-                        Text("Glance: usage only. Analyst: usage + credits/cost. Operator: full insights and actions.")
-                            .font(RunicFont.footnote)
-                            .foregroundStyle(.tertiary)
-                            .fixedSize(horizontal: false, vertical: true)
-                    }
-                    PreferenceToggleRow(
-                        title: "Show credits + extra usage",
-                        subtitle: "Show Codex Credits and Claude Extra usage sections in the menu.",
-                        binding: self.$settings.showOptionalCreditsAndExtraUsage)
-                    PreferenceToggleRow(
-                        title: "Merge Icons",
-                        subtitle: "Use a single menu bar icon with a provider switcher.",
-                        binding: self.$settings.mergeIcons)
-                    VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                        Text("Provider switcher layout")
-                            .font(RunicFont.body)
-                        Picker("", selection: self.$settings.providerSwitcherLayout) {
-                            ForEach(ProviderSwitcherLayout.allCases) { layout in
-                                Text(layout.label).tag(layout)
-                            }
-                        }
-                        .pickerStyle(.segmented)
-                        .disabled(!self.settings.mergeIcons)
-                        .opacity(self.settings.mergeIcons ? 1 : 0.5)
-                        Text("Choose whether providers appear on top or in a left sidebar.")
-                            .font(RunicFont.footnote)
-                            .foregroundStyle(.tertiary)
-                            .fixedSize(horizontal: false, vertical: true)
-                    }
-                    VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                        Text("Switcher icon size")
-                            .font(RunicFont.body)
-                        Picker("", selection: self.$settings.providerSwitcherIconSize) {
-                            ForEach(ProviderSwitcherIconSize.allCases) { size in
-                                Text(size.label).tag(size)
-                            }
-                        }
-                        .pickerStyle(.segmented)
-                        .disabled(!self.settings.mergeIcons)
-                        .opacity(self.settings.mergeIcons ? 1 : 0.5)
-                        Text("Small or medium icons for the provider switcher.")
-                            .font(RunicFont.footnote)
-                            .foregroundStyle(.tertiary)
-                            .fixedSize(horizontal: false, vertical: true)
-                    }
-                    PreferenceToggleRow(
-                        title: "Switcher shows icons",
-                        subtitle: "Show provider icons in the switcher (otherwise show a weekly progress line).",
-                        binding: self.$settings.switcherShowsIcons)
-                        .disabled(!self.settings.mergeIcons || self.settings.providerSwitcherLayout == .sidebar)
-                        .opacity(self.settings.mergeIcons && self.settings.providerSwitcherLayout != .sidebar ? 1 : 0.5)
-                    PreferenceToggleRow(
-                        title: "Menu bar shows percent",
-                        subtitle: "Replace critter bars with provider branding icons and a percentage.",
-                        binding: self.$settings.menuBarShowsBrandIconWithPercent)
-                    PreferenceToggleRow(
-                        title: "Surprise me",
-                        subtitle: "Check if you like your agents having some fun up there.",
-                        binding: self.$settings.randomBlinkEnabled)
-                }
-                .padding(.top, RunicSpacing.xs)
-            }
-            .disclosureGroupStyle(AnalyticsSectionDisclosureStyle())
-            .liquidGlass()
-            .liquidEntrance(appeared: self.appeared, index: 0)
-
-            // MARK: - Insights section
-
-            DisclosureGroup("Insights", isExpanded: self.$insightsExpanded) {
-                VStack(alignment: .leading, spacing: PreferencesLayoutMetrics.sectionSpacing) {
-                    PreferenceStepperRow(
-                        title: "Menu list size",
-                        subtitle: "Limits insight rows shown in the menu before \u{201C}More\u{2026}\u{201D}.",
-                        step: 1,
-                        range: 2...8,
-                        valueLabel: { "\($0) items" },
-                        value: self.$settings.insightsMenuMaxItems)
-                    PreferenceStepperRow(
-                        title: "Report window",
-                        subtitle: "Used when opening the Insights report.",
-                        step: 1,
-                        range: 1...30,
-                        valueLabel: { "Last \($0) days" },
-                        value: self.$settings.insightsReportDays)
-                }
-                .padding(.top, RunicSpacing.xs)
-            }
-            .disclosureGroupStyle(AnalyticsSectionDisclosureStyle())
-            .liquidGlass()
-            .liquidEntrance(appeared: self.appeared, index: 1)
-
-            // MARK: - Alerts section
-
-            DisclosureGroup("Alerts", isExpanded: self.$alertsExpanded) {
-                VStack(alignment: .leading, spacing: PreferencesLayoutMetrics.sectionSpacing) {
-                    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.alertRuleRow(rule)
-                                }
-                            }
-                            .padding(.vertical, RunicSpacing.xs)
-                        }
-                    }
-                }
-                .padding(.top, RunicSpacing.xs)
-            }
-            .disclosureGroupStyle(AnalyticsSectionDisclosureStyle())
-            .liquidGlass()
-            .liquidEntrance(appeared: self.appeared, index: 2)
-
-            // MARK: - Budgets section
-
-            DisclosureGroup("Budgets", isExpanded: self.$budgetsExpanded) {
-                VStack(alignment: .leading, spacing: PreferencesLayoutMetrics.sectionSpacing) {
-                    VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                        HStack {
-                            Text("\(self.budgets.count) budgets configured")
-                                .font(RunicFont.footnote)
-                                .foregroundStyle(.secondary)
-
-                            Spacer()
-
-                            Button {
-                                self.showingAddBudget = true
-                            } label: {
-                                Label("Add Budget", systemImage: "plus")
-                            }
-                            .buttonStyle(.bordered)
-                            .controlSize(.small)
-                        }
-
-                        if self.budgets.isEmpty {
-                            Text("No budgets configured. Add a budget to track project spending.")
-                                .font(RunicFont.footnote)
-                                .foregroundStyle(.tertiary)
-                                .padding(.vertical, RunicSpacing.md)
-                                .frame(maxWidth: .infinity)
-                        } else {
-                            VStack(spacing: RunicSpacing.xxs) {
-                                ForEach(self.budgets) { budget in
-                                    self.budgetRow(budget)
-                                }
-                            }
-                            .padding(.vertical, RunicSpacing.xs)
-                        }
-
-                        if let error = self.budgetErrorMessage {
-                            HStack(alignment: .center, spacing: RunicSpacing.xs) {
-                                Image(systemName: "exclamationmark.triangle.fill")
-                                    .font(RunicFont.caption)
-                                    .foregroundStyle(.red)
-                                Text(error)
-                                    .font(RunicFont.caption)
-                                    .foregroundStyle(.red)
-                            }
-                            .padding(RunicSpacing.xs)
-                            .background(Color.red.opacity(0.1))
-                            .cornerRadius(RunicCornerRadius.sm)
-                        }
-                    }
-                }
-                .padding(.top, RunicSpacing.xs)
-            }
-            .disclosureGroupStyle(AnalyticsSectionDisclosureStyle())
-            .liquidGlass()
-            .liquidEntrance(appeared: self.appeared, index: 3)
-        }
-        .onAppear {
-            self.alertsData = AlertRuleStore.load()
-            self.budgets = ProjectBudgetStore.getAllBudgets()
-            if !self.appeared { withAnimation(.easeOut(duration: 0.6)) { self.appeared = true } }
-        }
-        .sheet(isPresented: self.$showingAddRule) {
-            AnalyticsRuleEditorSheet(
-                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
-            AnalyticsRuleEditorSheet(
-                rule: rule,
-                onSave: { updatedRule in
-                    do {
-                        try AlertRuleStore.updateRule(updatedRule)
-                        self.alertsData = AlertRuleStore.load()
-                    } catch {
-                        print("Failed to update rule: \(error)")
-                    }
-                })
-        }
-        .sheet(isPresented: self.$showingAddBudget) {
-            AnalyticsAddBudgetSheet(
-                projectID: self.$newProjectID,
-                projectName: self.$newProjectName,
-                monthlyLimit: self.$newMonthlyLimit,
-                alertThreshold: self.$newAlertThreshold,
-                onAdd: { self.addBudget() },
-                onCancel: {
-                    self.showingAddBudget = false
-                    self.resetNewBudgetFields()
-                })
-        }
-    }
-
-    // MARK: - Alert rule row
-
-    private func alertRuleRow(_ 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)
-    }
-
-    // MARK: - Budget row
-
-    private func budgetRow(_ budget: ProjectBudgetStore.ProjectBudget) -> some View {
-        HStack(spacing: RunicSpacing.sm) {
-            VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
-                Text(budget.projectName ?? budget.projectID)
-                    .font(RunicFont.body)
-                    .lineLimit(1)
-                    .truncationMode(.tail)
-
-                HStack(spacing: RunicSpacing.xs) {
-                    Text(UsageFormatter.usdString(budget.monthlyLimit))
-                        .font(RunicFont.footnote)
-                        .foregroundStyle(.secondary)
-                    Text("Alert at \(String(format: "%.0f%%", budget.alertThreshold * 100))")
-                        .font(RunicFont.footnote)
-                        .foregroundStyle(.secondary)
-                }
-            }
-
-            Spacer()
-
-            Text(budget.enabled ? "Enabled" : "Disabled")
-                .font(RunicFont.caption)
-                .foregroundStyle(budget.enabled ? .green : .secondary)
-
-            Button {
-                self.deleteBudget(budget)
-            } label: {
-                Image(systemName: "trash")
-                    .font(RunicFont.caption)
-                    .foregroundStyle(.red)
-            }
-            .buttonStyle(.plain)
-        }
-        .padding(RunicSpacing.xs)
-        .background(Color(nsColor: .controlBackgroundColor))
-        .cornerRadius(RunicCornerRadius.sm)
-    }
-
-    // MARK: - Helpers
-
-    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 deleteRule(_ rule: AlertRuleStore.AlertRule) {
-        try? AlertRuleStore.removeRule(id: rule.id)
-        self.alertsData = AlertRuleStore.load()
-    }
-
-    private func addBudget() {
-        guard !self.newProjectID.isEmpty else {
-            self.budgetErrorMessage = "Project ID is required"
-            return
-        }
-
-        guard let limit = Double(self.newMonthlyLimit), limit > 0 else {
-            self.budgetErrorMessage = "Monthly limit must be a positive number"
-            return
-        }
-
-        guard let threshold = Double(self.newAlertThreshold), threshold > 0, threshold <= 100 else {
-            self.budgetErrorMessage = "Alert threshold must be between 1 and 100"
-            return
-        }
-
-        let budget = ProjectBudgetStore.ProjectBudget(
-            projectID: self.newProjectID,
-            projectName: self.newProjectName.isEmpty ? nil : self.newProjectName,
-            monthlyLimit: limit,
-            alertThreshold: threshold / 100.0,
-            enabled: true)
-
-        do {
-            try ProjectBudgetStore.setBudget(budget)
-            self.budgets = ProjectBudgetStore.getAllBudgets()
-            self.showingAddBudget = false
-            self.resetNewBudgetFields()
-            self.budgetErrorMessage = nil
-        } catch {
-            self.budgetErrorMessage = "Failed to add budget: \(error.localizedDescription)"
-        }
-    }
-
-    private func deleteBudget(_ budget: ProjectBudgetStore.ProjectBudget) {
-        do {
-            try ProjectBudgetStore.removeBudget(projectID: budget.projectID)
-            self.budgets = ProjectBudgetStore.getAllBudgets()
-            self.budgetErrorMessage = nil
-        } catch {
-            self.budgetErrorMessage = "Failed to delete: \(error.localizedDescription)"
-        }
-    }
-
-    private func resetNewBudgetFields() {
-        self.newProjectID = ""
-        self.newProjectName = ""
-        self.newMonthlyLimit = ""
-        self.newAlertThreshold = "80"
-    }
-}
-
-// MARK: - Disclosure Group Style
-
-private struct AnalyticsSectionDisclosureStyle: DisclosureGroupStyle {
-    func makeBody(configuration: Configuration) -> some View {
-        VStack(alignment: .leading, spacing: 0) {
-            Button {
-                withAnimation(.easeInOut(duration: 0.2)) {
-                    configuration.isExpanded.toggle()
-                }
-            } label: {
-                HStack(spacing: RunicSpacing.xs) {
-                    Image(systemName: configuration.isExpanded ? "chevron.down" : "chevron.right")
-                        .font(RunicFont.caption.weight(.semibold))
-                        .foregroundStyle(.secondary)
-                        .frame(width: 12)
-                    configuration.label
-                        .font(RunicFont.caption)
-                        .foregroundStyle(.secondary)
-                        .textCase(.uppercase)
-                    Spacer()
-                }
-                .contentShape(Rectangle())
-            }
-            .buttonStyle(.plain)
-
-            if configuration.isExpanded {
-                configuration.content
-            }
-        }
-    }
-}
-
-// MARK: - Rule Editor Sheet
-
-@MainActor
-private struct AnalyticsRuleEditorSheet: 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,
-                        enabled: self.rule?.enabled ?? true,
-                        createdAt: self.rule?.createdAt ?? Date())
-                    self.onSave(newRule)
-                    self.dismiss()
-                }
-                .keyboardShortcut(.defaultAction)
-            }
-        }
-        .padding(RunicSpacing.lg)
-        .frame(width: 400)
-    }
-}
-
-// MARK: - Add Budget Sheet
-
-@MainActor
-private struct AnalyticsAddBudgetSheet: View {
-    @Binding var projectID: String
-    @Binding var projectName: String
-    @Binding var monthlyLimit: String
-    @Binding var alertThreshold: String
-    let onAdd: () -> Void
-    let onCancel: () -> Void
-
-    var body: some View {
-        VStack(alignment: .leading, spacing: RunicSpacing.md) {
-            Text("Add Budget")
-                .font(RunicFont.title2)
-                .fontWeight(.semibold)
-
-            Form {
-                TextField("Project ID", text: self.$projectID)
-                    .textFieldStyle(.roundedBorder)
-                TextField("Project Name (optional)", text: self.$projectName)
-                    .textFieldStyle(.roundedBorder)
-                TextField("Monthly Limit (USD)", text: self.$monthlyLimit)
-                    .textFieldStyle(.roundedBorder)
-                TextField("Alert Threshold (%)", text: self.$alertThreshold)
-                    .textFieldStyle(.roundedBorder)
-            }
-
-            HStack {
-                Button("Cancel", action: self.onCancel)
-                    .buttonStyle(.bordered)
-                Spacer()
-                Button("Add", action: self.onAdd)
-                    .buttonStyle(.borderedProminent)
-            }
-        }
-        .padding(RunicSpacing.lg)
-        .frame(width: 400)
-    }
-}