@sriinnu/runic 1.0.0

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

@@ -0,0 +1,344 @@
+import RunicCore
+import SwiftUI
+
+@MainActor
+struct PreferencesBudgetsPane: View {
+    @State private var budgets: [ProjectBudgetStore.ProjectBudget] = []
+    @State private var editingProjectID: String?
+    @State private var showingAddDialog = false
+    @State private var newProjectID = ""
+    @State private var newProjectName = ""
+    @State private var newMonthlyLimit = ""
+    @State private var newAlertThreshold = "80"
+    @State private var errorMessage: String?
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: RunicSpacing.md) {
+            VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+                Text("Project Budgets")
+                    .font(.title2)
+                    .fontWeight(.semibold)
+                Text("Set monthly spending limits and alerts for projects.")
+                    .font(.subheadline)
+                    .foregroundStyle(.secondary)
+            }
+
+            if self.budgets.isEmpty {
+                VStack(spacing: RunicSpacing.md) {
+                    Text("No budgets configured")
+                        .font(.body)
+                        .foregroundStyle(.secondary)
+                        .padding(.vertical, RunicSpacing.lg)
+
+                    Button {
+                        self.showingAddDialog = true
+                    } label: {
+                        Label("Add Budget", systemImage: "plus.circle.fill")
+                    }
+                    .buttonStyle(.borderedProminent)
+                }
+                .frame(maxWidth: .infinity)
+                .padding(.vertical, RunicSpacing.xl)
+            } else {
+                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+                    // Header
+                    HStack(alignment: .center, spacing: RunicSpacing.sm) {
+                        Text("Project")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                            .frame(width: 150, alignment: .leading)
+                        Text("Monthly Limit")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                            .frame(width: 120, alignment: .leading)
+                        Text("Alert at")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                            .frame(width: 80, alignment: .leading)
+                        Text("Status")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                            .frame(width: 80, alignment: .leading)
+                        Spacer()
+                    }
+                    .padding(.horizontal, RunicSpacing.xs)
+
+                    Divider()
+
+                    ScrollView {
+                        VStack(spacing: RunicSpacing.xxs) {
+                            ForEach(self.budgets) { budget in
+                                BudgetRow(
+                                    budget: budget,
+                                    isEditing: self.editingProjectID == budget.projectID,
+                                    onEdit: {
+                                        self.editingProjectID = budget.projectID
+                                    },
+                                    onSave: { updated in
+                                        do {
+                                            try ProjectBudgetStore.setBudget(updated)
+                                            self.loadBudgets()
+                                            self.editingProjectID = nil
+                                            self.errorMessage = nil
+                                        } catch {
+                                            self.errorMessage = "Failed to save: \(error.localizedDescription)"
+                                        }
+                                    },
+                                    onCancel: {
+                                        self.editingProjectID = nil
+                                    },
+                                    onDelete: {
+                                        self.deleteBudget(budget)
+                                    })
+                            }
+                        }
+                    }
+                    .frame(maxHeight: 400)
+
+                    Button {
+                        self.showingAddDialog = true
+                    } label: {
+                        Label("Add Budget", systemImage: "plus")
+                    }
+                    .buttonStyle(.plain)
+                }
+            }
+
+            if let error = self.errorMessage {
+                HStack(alignment: .center, spacing: RunicSpacing.xs) {
+                    Image(systemName: "exclamationmark.triangle.fill")
+                        .font(.caption)
+                        .foregroundStyle(.red)
+                        .alignmentGuide(.firstTextBaseline) { d in d[VerticalAlignment.center] }
+                    Text(error)
+                        .font(.caption)
+                        .foregroundStyle(.red)
+                }
+                .padding(RunicSpacing.xs)
+                .background(Color.red.opacity(0.1))
+                .cornerRadius(RunicCornerRadius.sm)
+            }
+
+            Spacer()
+        }
+        .padding(RunicSpacing.lg)
+        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+        .onAppear {
+            self.loadBudgets()
+        }
+        .sheet(isPresented: self.$showingAddDialog) {
+            AddBudgetSheet(
+                projectID: self.$newProjectID,
+                projectName: self.$newProjectName,
+                monthlyLimit: self.$newMonthlyLimit,
+                alertThreshold: self.$newAlertThreshold,
+                onAdd: { self.addBudget() },
+                onCancel: {
+                    self.showingAddDialog = false
+                    self.resetNewBudgetFields()
+                })
+        }
+    }
+
+    private func loadBudgets() {
+        self.budgets = ProjectBudgetStore.getAllBudgets()
+    }
+
+    private func addBudget() {
+        guard !self.newProjectID.isEmpty else {
+            self.errorMessage = "Project ID is required"
+            return
+        }
+
+        guard let limit = Double(self.newMonthlyLimit), limit > 0 else {
+            self.errorMessage = "Monthly limit must be a positive number"
+            return
+        }
+
+        guard let threshold = Double(self.newAlertThreshold), threshold > 0, threshold <= 100 else {
+            self.errorMessage = "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.loadBudgets()
+            self.showingAddDialog = false
+            self.resetNewBudgetFields()
+            self.errorMessage = nil
+        } catch {
+            self.errorMessage = "Failed to add budget: \(error.localizedDescription)"
+        }
+    }
+
+    private func deleteBudget(_ budget: ProjectBudgetStore.ProjectBudget) {
+        do {
+            try ProjectBudgetStore.removeBudget(projectID: budget.projectID)
+            self.loadBudgets()
+            self.errorMessage = nil
+        } catch {
+            self.errorMessage = "Failed to delete: \(error.localizedDescription)"
+        }
+    }
+
+    private func resetNewBudgetFields() {
+        self.newProjectID = ""
+        self.newProjectName = ""
+        self.newMonthlyLimit = ""
+        self.newAlertThreshold = "80"
+    }
+}
+
+private struct BudgetRow: View {
+    let budget: ProjectBudgetStore.ProjectBudget
+    let isEditing: Bool
+    let onEdit: () -> Void
+    let onSave: (ProjectBudgetStore.ProjectBudget) -> Void
+    let onCancel: () -> Void
+    let onDelete: () -> Void
+
+    @State private var editName: String
+    @State private var editLimit: String
+    @State private var editThreshold: String
+
+    init(
+        budget: ProjectBudgetStore.ProjectBudget,
+        isEditing: Bool,
+        onEdit: @escaping () -> Void,
+        onSave: @escaping (ProjectBudgetStore.ProjectBudget) -> Void,
+        onCancel: @escaping () -> Void,
+        onDelete: @escaping () -> Void)
+    {
+        self.budget = budget
+        self.isEditing = isEditing
+        self.onEdit = onEdit
+        self.onSave = onSave
+        self.onCancel = onCancel
+        self.onDelete = onDelete
+        self._editName = State(initialValue: budget.projectName ?? "")
+        self._editLimit = State(initialValue: String(format: "%.2f", budget.monthlyLimit))
+        self._editThreshold = State(initialValue: String(format: "%.0f", budget.alertThreshold * 100))
+    }
+
+    var body: some View {
+        HStack(alignment: .center, spacing: RunicSpacing.sm) {
+            if self.isEditing {
+                TextField("Name", text: self.$editName)
+                    .textFieldStyle(.roundedBorder)
+                    .frame(width: 150, alignment: .leading)
+                TextField("Limit", text: self.$editLimit)
+                    .textFieldStyle(.roundedBorder)
+                    .frame(width: 120, alignment: .leading)
+                TextField("%", text: self.$editThreshold)
+                    .textFieldStyle(.roundedBorder)
+                    .frame(width: 80, alignment: .leading)
+                Spacer()
+                HStack(spacing: RunicSpacing.xs) {
+                    Button("Save") {
+                        guard let limit = Double(self.editLimit), limit > 0,
+                              let threshold = Double(self.editThreshold), threshold > 0, threshold <= 100
+                        else { return }
+
+                        let updated = ProjectBudgetStore.ProjectBudget(
+                            projectID: self.budget.projectID,
+                            projectName: self.editName.isEmpty ? nil : self.editName,
+                            monthlyLimit: limit,
+                            alertThreshold: threshold / 100.0,
+                            enabled: self.budget.enabled,
+                            createdAt: self.budget.createdAt)
+                        self.onSave(updated)
+                    }
+                    .buttonStyle(.borderedProminent)
+                    .controlSize(.small)
+                    Button("Cancel", action: self.onCancel)
+                        .buttonStyle(.bordered)
+                        .controlSize(.small)
+                }
+            } else {
+                Text(budget.projectName ?? budget.projectID)
+                    .font(.body)
+                    .frame(width: 150, alignment: .leading)
+                    .lineLimit(1)
+                    .truncationMode(.tail)
+                Text(UsageFormatter.usdString(budget.monthlyLimit))
+                    .font(.body)
+                    .frame(width: 120, alignment: .leading)
+                Text(String(format: "%.0f%%", budget.alertThreshold * 100))
+                    .font(.body)
+                    .frame(width: 80, alignment: .leading)
+                Text(budget.enabled ? "Enabled" : "Disabled")
+                    .font(.caption)
+                    .foregroundStyle(budget.enabled ? .green : .secondary)
+                    .frame(width: 80, alignment: .leading)
+                    .alignmentGuide(.firstTextBaseline) { d in d[VerticalAlignment.center] }
+                Spacer()
+                HStack(spacing: RunicSpacing.xs) {
+                    Button {
+                        self.onEdit()
+                    } label: {
+                        Image(systemName: "pencil")
+                            .font(.caption)
+                    }
+                    .buttonStyle(.plain)
+                    Button {
+                        self.onDelete()
+                    } label: {
+                        Image(systemName: "trash")
+                            .font(.caption)
+                            .foregroundStyle(.red)
+                    }
+                    .buttonStyle(.plain)
+                }
+            }
+        }
+        .padding(.horizontal, RunicSpacing.xs)
+        .padding(.vertical, RunicSpacing.xxs)
+        .background(Color(nsColor: .controlBackgroundColor))
+        .cornerRadius(RunicCornerRadius.xs)
+    }
+}
+
+private struct AddBudgetSheet: 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(.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)
+    }
+}

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

@@ -0,0 +1,230 @@
+import AppKit
+import SwiftUI
+
+enum PreferencesLayoutMetrics {
+    static let outerHorizontal: CGFloat = 0
+    static let outerVertical: CGFloat = 0
+    static let paneHorizontal: CGFloat = 36
+    static let paneVertical: CGFloat = 24
+    static let paneSpacing: CGFloat = 24
+    static let sectionSpacing: CGFloat = 20
+    static let sectionHeaderSpacing: CGFloat = 16
+}
+
+@MainActor
+struct PreferencesPane<Content: View>: View {
+    let showsIndicators: Bool
+    private let content: () -> Content
+
+    init(
+        showsIndicators: Bool = true,
+        @ViewBuilder content: @escaping () -> Content)
+    {
+        self.showsIndicators = showsIndicators
+        self.content = content
+    }
+
+    var body: some View {
+        ScrollView(.vertical, showsIndicators: self.showsIndicators) {
+            VStack(alignment: .leading, spacing: PreferencesLayoutMetrics.paneSpacing) {
+                self.content()
+            }
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding(.horizontal, PreferencesLayoutMetrics.paneHorizontal)
+            .padding(.vertical, PreferencesLayoutMetrics.paneVertical)
+        }
+    }
+}
+
+@MainActor
+struct PreferencesListPane<Content: View>: View {
+    let horizontalPadding: CGFloat
+    let verticalPadding: CGFloat
+    private let content: () -> Content
+
+    init(
+        horizontalPadding: CGFloat = PreferencesLayoutMetrics.paneHorizontal,
+        verticalPadding: CGFloat = PreferencesLayoutMetrics.paneVertical,
+        @ViewBuilder content: @escaping () -> Content)
+    {
+        self.horizontalPadding = horizontalPadding
+        self.verticalPadding = verticalPadding
+        self.content = content
+    }
+
+    var body: some View {
+        self.content()
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding(.horizontal, self.horizontalPadding)
+            .padding(.vertical, self.verticalPadding)
+    }
+}
+
+@MainActor
+struct PreferenceToggleRow: View {
+    let title: String
+    let subtitle: String?
+    @Binding var binding: Bool
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+            HStack(alignment: .center, spacing: RunicSpacing.xs) {
+                Toggle(isOn: self.$binding) {
+                    Text(self.title)
+                        .font(.body)
+                }
+                .toggleStyle(.checkbox)
+                .alignmentGuide(.firstTextBaseline) { d in d[VerticalAlignment.center] }
+            }
+
+            if let subtitle, !subtitle.isEmpty {
+                Text(subtitle)
+                    .font(.footnote)
+                    .foregroundStyle(.tertiary)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+        }
+    }
+}
+
+@MainActor
+struct PreferenceStepperRow: View {
+    let title: String
+    let subtitle: String?
+    let step: Int
+    let range: ClosedRange<Int>
+    let valueLabel: (Int) -> String
+    @Binding var value: Int
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+            HStack(spacing: RunicSpacing.sm) {
+                Text(self.title)
+                    .font(.body)
+                Spacer()
+                PreferenceStepperControl(
+                    valueLabel: self.valueLabel(self.value),
+                    canDecrement: self.value - self.step >= self.range.lowerBound,
+                    canIncrement: self.value + self.step <= self.range.upperBound,
+                    onDecrement: { self.value = max(self.range.lowerBound, self.value - self.step) },
+                    onIncrement: { self.value = min(self.range.upperBound, self.value + self.step) })
+            }
+
+            if let subtitle, !subtitle.isEmpty {
+                Text(subtitle)
+                    .font(.footnote)
+                    .foregroundStyle(.tertiary)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+        }
+    }
+}
+
+@MainActor
+struct PreferencesDivider: View {
+    var body: some View {
+        Divider()
+            .padding(.vertical, RunicSpacing.xxs)
+    }
+}
+
+@MainActor
+private struct PreferenceStepperControl: View {
+    let valueLabel: String
+    let canDecrement: Bool
+    let canIncrement: Bool
+    let onDecrement: () -> Void
+    let onIncrement: () -> Void
+
+    var body: some View {
+        HStack(spacing: RunicSpacing.xs) {
+            Button(action: self.onDecrement) {
+                Image(systemName: "minus")
+            }
+            .buttonStyle(.bordered)
+            .controlSize(.small)
+            .disabled(!self.canDecrement)
+
+            Text(self.valueLabel)
+                .font(.footnote.weight(.semibold))
+                .foregroundStyle(.secondary)
+                .padding(.horizontal, RunicSpacing.sm)
+                .padding(.vertical, RunicSpacing.xxs)
+                .background(
+                    RoundedRectangle(cornerRadius: RunicCornerRadius.sm, style: .continuous)
+                        .fill(Color(nsColor: .controlBackgroundColor)))
+
+            Button(action: self.onIncrement) {
+                Image(systemName: "plus")
+            }
+            .buttonStyle(.bordered)
+            .controlSize(.small)
+            .disabled(!self.canIncrement)
+        }
+    }
+}
+
+@MainActor
+struct SettingsSection<Content: View>: View {
+    let title: String?
+    let caption: String?
+    let contentSpacing: CGFloat
+    private let content: () -> Content
+
+    init(
+        title: String? = nil,
+        caption: String? = nil,
+        contentSpacing: CGFloat = PreferencesLayoutMetrics.sectionSpacing,
+        @ViewBuilder content: @escaping () -> Content)
+    {
+        self.title = title
+        self.caption = caption
+        self.contentSpacing = contentSpacing
+        self.content = content
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: PreferencesLayoutMetrics.sectionHeaderSpacing) {
+            if let title, !title.isEmpty {
+                Text(title)
+                    .font(.subheadline.weight(.semibold))
+            }
+            if let caption {
+                Text(caption)
+                    .font(.footnote)
+                    .foregroundStyle(.tertiary)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+            VStack(alignment: .leading, spacing: self.contentSpacing) {
+                self.content()
+            }
+            .frame(maxWidth: .infinity, alignment: .leading)
+        }
+    }
+}
+
+@MainActor
+struct AboutLinkRow: View {
+    let icon: String
+    let title: String
+    let url: String
+    @State private var hovering = false
+
+    var body: some View {
+        Button {
+            if let url = URL(string: self.url) { NSWorkspace.shared.open(url) }
+        } label: {
+            HStack(spacing: RunicSpacing.xs) {
+                Image(systemName: self.icon)
+                Text(self.title)
+                    .underline(self.hovering, color: .accentColor)
+            }
+            .frame(maxWidth: .infinity)
+            .padding(.vertical, RunicSpacing.xxs)
+            .foregroundColor(.accentColor)
+        }
+        .buttonStyle(.plain)
+        .contentShape(Rectangle())
+        .onHover { self.hovering = $0 }
+    }
+}