@sriinnu/runic 1.0.0

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

@@ -0,0 +1,25 @@
+import Foundation
+import Observation
+
+@MainActor
+@Observable
+final class PreferencesSelection {
+    var tab: PreferencesTab = .general
+}
+
+enum PreferencesTab: String, Hashable, CaseIterable, Identifiable {
+    case general
+    case providers
+    case analytics
+    case sync
+    case performance
+    case about
+    case debug
+
+    var id: String { self.rawValue }
+
+    static let windowWidth: CGFloat = 560
+    static let windowHeight: CGFloat = 726
+
+    var preferredHeight: CGFloat { PreferencesTab.windowHeight }
+}

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

@@ -0,0 +1,59 @@
+import AppKit
+import RunicCore
+import SwiftUI
+
+@MainActor
+struct SyncPane: View {
+    @Bindable var settings: SettingsStore
+    @Bindable var store: UsageStore
+
+    @State private var selectedSection: SyncSection = .integrations
+
+    enum SyncSection: String, CaseIterable, Identifiable {
+        case integrations
+        case teams
+
+        var id: String { self.rawValue }
+
+        var label: String {
+            switch self {
+            case .integrations: return "Integrations"
+            case .teams: return "Teams"
+            }
+        }
+
+        var icon: String {
+            switch self {
+            case .integrations: return "link"
+            case .teams: return "person.3"
+            }
+        }
+    }
+
+    var body: some View {
+        ZStack {
+            LiquidMeshBackground()
+                .ignoresSafeArea()
+                .opacity(0.3)
+
+            VStack(spacing: 0) {
+                Picker("", selection: self.$selectedSection) {
+                    ForEach(SyncSection.allCases) { section in
+                        Label(section.label, systemImage: section.icon).tag(section)
+                    }
+                }
+                .pickerStyle(.segmented)
+                .padding(.horizontal, PreferencesLayoutMetrics.paneHorizontal)
+                .padding(.top, PreferencesLayoutMetrics.paneVertical)
+                .padding(.bottom, RunicSpacing.sm)
+
+                switch self.selectedSection {
+                case .integrations:
+                    IntegrationsPane(settings: self.settings, store: self.store)
+                case .teams:
+                    TeamManagementView(settings: self.settings, store: self.store)
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,206 @@
+import AppKit
+import SwiftUI
+
+@MainActor
+struct PreferencesView: View {
+    @Bindable var settings: SettingsStore
+    @Bindable var store: UsageStore
+    let updater: UpdaterProviding
+    @Bindable var selection: PreferencesSelection
+
+    @State private var providersSection: ProvidersSubSection = .builtIn
+    @State private var performanceSection: PerformanceSubSection = .monitoring
+    @State private var aboutSection: AboutSubSection = .about
+
+    // MARK: - Sub-section enums
+
+    enum ProvidersSubSection: String, CaseIterable, Identifiable {
+        case builtIn
+        case custom
+
+        var id: String { self.rawValue }
+
+        var label: String {
+            switch self {
+            case .builtIn: return "Built-in"
+            case .custom: return "Custom"
+            }
+        }
+    }
+
+    enum PerformanceSubSection: String, CaseIterable, Identifiable {
+        case monitoring
+        case refresh
+
+        var id: String { self.rawValue }
+
+        var label: String {
+            switch self {
+            case .monitoring: return "Monitoring"
+            case .refresh: return "Refresh & Safety"
+            }
+        }
+    }
+
+    enum AboutSubSection: String, CaseIterable, Identifiable {
+        case about
+        case help
+
+        var id: String { self.rawValue }
+
+        var label: String {
+            switch self {
+            case .about: return "About"
+            case .help: return "Help"
+            }
+        }
+    }
+
+    var body: some View {
+        TabView(selection: self.$selection.tab) {
+            // MARK: - General
+
+            GeneralPane(settings: self.settings, store: self.store)
+                .tabItem {
+                    Label("General", systemImage: "gearshape")
+                }
+                .tag(PreferencesTab.general)
+
+            // MARK: - Providers (Built-in + Custom)
+
+            ZStack {
+                LiquidMeshBackground().ignoresSafeArea().opacity(0.3)
+                VStack(spacing: 0) {
+                    HStack(spacing: RunicSpacing.xs) {
+                    Picker("", selection: self.$providersSection) {
+                        ForEach(ProvidersSubSection.allCases) { section in
+                            Text(section.label).tag(section)
+                        }
+                    }
+                    .pickerStyle(.segmented)
+
+                    if self.providersSection == .builtIn {
+                        Picker("", selection: self.$settings.providersPaneSidebar) {
+                            Text("List").tag(false)
+                            Text("Sidebar").tag(true)
+                        }
+                        .pickerStyle(.segmented)
+                        .controlSize(.small)
+                    }
+                }
+                .padding(.horizontal, PreferencesLayoutMetrics.paneHorizontal)
+                .padding(.top, RunicSpacing.sm)
+                .padding(.bottom, RunicSpacing.xs)
+
+                switch self.providersSection {
+                case .builtIn:
+                    ProvidersPane(settings: self.settings, store: self.store)
+                case .custom:
+                    CustomProvidersPane(settings: self.settings, store: self.store)
+                }
+                }
+            }
+            .tabItem {
+                Label("Providers", systemImage: "square.grid.2x2")
+            }
+            .tag(PreferencesTab.providers)
+
+            // MARK: - Analytics (Display + Insights + Alerts + Budgets)
+
+            AnalyticsPane(settings: self.settings, store: self.store)
+                .tabItem {
+                    Label("Analytics", systemImage: "chart.bar.xaxis")
+                }
+                .tag(PreferencesTab.analytics)
+
+            // MARK: - Sync (Integrations + Teams)
+
+            SyncPane(settings: self.settings, store: self.store)
+                .tabItem {
+                    Label("Sync", systemImage: "arrow.triangle.2.circlepath")
+                }
+                .tag(PreferencesTab.sync)
+
+            // MARK: - Performance (Monitoring + Refresh/Safety)
+
+            VStack(spacing: 0) {
+                Picker("", selection: self.$performanceSection) {
+                    ForEach(PerformanceSubSection.allCases) { section in
+                        Text(section.label).tag(section)
+                    }
+                }
+                .pickerStyle(.segmented)
+                .padding(.horizontal, PreferencesLayoutMetrics.paneHorizontal)
+                .padding(.top, RunicSpacing.sm)
+                .padding(.bottom, RunicSpacing.xs)
+
+                switch self.performanceSection {
+                case .monitoring:
+                    PerformancePane(settings: self.settings, store: self.store)
+                case .refresh:
+                    AdvancedPane(settings: self.settings, store: self.store)
+                }
+            }
+            .tabItem {
+                Label("Performance", systemImage: "speedometer")
+            }
+            .tag(PreferencesTab.performance)
+
+            // MARK: - About (About + Help)
+
+            VStack(spacing: 0) {
+                Picker("", selection: self.$aboutSection) {
+                    ForEach(AboutSubSection.allCases) { section in
+                        Text(section.label).tag(section)
+                    }
+                }
+                .pickerStyle(.segmented)
+                .padding(.horizontal, PreferencesLayoutMetrics.paneHorizontal)
+                .padding(.top, RunicSpacing.sm)
+                .padding(.bottom, RunicSpacing.xs)
+
+                switch self.aboutSection {
+                case .about:
+                    AboutPane(updater: self.updater)
+                case .help:
+                    HelpPane()
+                }
+            }
+            .tabItem {
+                Label("About", systemImage: "info.circle")
+            }
+            .tag(PreferencesTab.about)
+
+            // MARK: - Debug (conditional)
+
+            if self.settings.debugMenuEnabled {
+                DebugPane(settings: self.settings, store: self.store)
+                    .tabItem {
+                        Label("Debug", systemImage: "ladybug")
+                    }
+                    .tag(PreferencesTab.debug)
+            }
+        }
+        .tabViewStyle(.automatic)
+        .frame(
+            minWidth: PreferencesTab.windowWidth,
+            idealWidth: PreferencesTab.windowWidth,
+            maxWidth: PreferencesTab.windowWidth,
+            minHeight: PreferencesTab.windowHeight,
+            idealHeight: PreferencesTab.windowHeight,
+            maxHeight: .infinity,
+            alignment: .center)
+        .onAppear {
+            self.ensureValidTabSelection()
+        }
+        .onChange(of: self.settings.debugMenuEnabled) { _, _ in
+            self.ensureValidTabSelection()
+        }
+    }
+
+    private func ensureValidTabSelection() {
+        if !self.settings.debugMenuEnabled, self.selection.tab == .debug {
+            self.selection.tab = .general
+        }
+    }
+}

package/Sources/Runic/Views/Rating/QualityRatingView.swift

@@ -0,0 +1,238 @@
+import RunicCore
+import SwiftUI
+
+/// Inline quality rating UI for AI model interactions (1-5 stars)
+struct QualityRatingView: View {
+
+    // MARK: - Types
+
+    struct Model {
+        let requestID: String
+        let provider: UsageProvider
+        let model: String?
+        let sessionID: String?
+        let onSubmit: (Int, String?) async -> Void
+    }
+
+    // MARK: - State
+
+    private let model: Model
+    @State private var selectedRating: Int?
+    @State private var comment: String = ""
+    @State private var isSubmitting = false
+    @State private var didSubmit = false
+    @State private var errorMessage: String?
+    @FocusState private var isCommentFocused: Bool
+
+    // MARK: - Initialization
+
+    init(model: Model) {
+        self.model = model
+    }
+
+    // MARK: - Body
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+            if self.didSubmit {
+                self.thankYouView
+            } else {
+                self.ratingSelector
+                if self.selectedRating != nil {
+                    self.commentField
+                    self.submitButton
+                }
+                if let error = self.errorMessage {
+                    self.errorView(error)
+                }
+            }
+        }
+        .padding(RunicSpacing.sm)
+        .background(Color(nsColor: .controlBackgroundColor))
+        .clipShape(RoundedRectangle(cornerRadius: 8))
+    }
+
+    // MARK: - Rating Selector
+
+    private var ratingSelector: some View {
+        VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+            Text("How would you rate this response?")
+                .font(.subheadline)
+                .fontWeight(.medium)
+
+            HStack(spacing: RunicSpacing.xs) {
+                ForEach(1...5, id: \.self) { rating in
+                    Button {
+                        self.selectRating(rating)
+                    } label: {
+                        Image(systemName: self.starIcon(for: rating))
+                            .font(.title2)
+                            .foregroundStyle(self.starColor(for: rating))
+                            .contentShape(Rectangle())
+                    }
+                    .buttonStyle(.plain)
+                    .accessibilityLabel("\(rating) star\(rating == 1 ? "" : "s")")
+                    .accessibilityAddTraits(self.selectedRating == rating ? [.isSelected] : [])
+                }
+            }
+        }
+    }
+
+    private func starIcon(for rating: Int) -> String {
+        if let selected = self.selectedRating {
+            return rating <= selected ? "star.fill" : "star"
+        }
+        return "star"
+    }
+
+    private func starColor(for rating: Int) -> Color {
+        guard let selected = self.selectedRating else {
+            return Color(nsColor: .secondaryLabelColor)
+        }
+
+        if rating <= selected {
+            // Color gradient from red (1 star) to yellow (5 stars)
+            switch selected {
+            case 1, 2: return .red
+            case 3: return .orange
+            case 4, 5: return .yellow
+            default: return .yellow
+            }
+        }
+
+        return Color(nsColor: .tertiaryLabelColor)
+    }
+
+    private func selectRating(_ rating: Int) {
+        withAnimation(.easeInOut(duration: 0.2)) {
+            self.selectedRating = rating
+        }
+    }
+
+    // MARK: - Comment Field
+
+    private var commentField: some View {
+        VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+            Text("Additional feedback (optional)")
+                .font(.caption)
+                .foregroundStyle(.secondary)
+
+            TextField("Share your thoughts...", text: self.$comment, axis: .vertical)
+                .textFieldStyle(.plain)
+                .lineLimit(3...6)
+                .padding(RunicSpacing.xs)
+                .background(Color(nsColor: .textBackgroundColor))
+                .clipShape(RoundedRectangle(cornerRadius: 6))
+                .focused(self.$isCommentFocused)
+        }
+    }
+
+    // MARK: - Submit Button
+
+    private var submitButton: some View {
+        HStack {
+            Spacer()
+
+            Button {
+                Task {
+                    await self.submitRating()
+                }
+            } label: {
+                HStack(spacing: 4) {
+                    if self.isSubmitting {
+                        ProgressView()
+                            .controlSize(.small)
+                            .frame(width: 12, height: 12)
+                    }
+                    Text(self.isSubmitting ? "Submitting..." : "Submit Rating")
+                        .font(.subheadline)
+                        .fontWeight(.medium)
+                }
+                .padding(.horizontal, RunicSpacing.sm)
+                .padding(.vertical, RunicSpacing.xxs)
+            }
+            .buttonStyle(.borderedProminent)
+            .disabled(self.isSubmitting)
+        }
+    }
+
+    // MARK: - Thank You View
+
+    private var thankYouView: some View {
+        HStack(spacing: RunicSpacing.xs) {
+            Image(systemName: "checkmark.circle.fill")
+                .font(.title3)
+                .foregroundStyle(.green)
+
+            VStack(alignment: .leading, spacing: 2) {
+                Text("Thank you for your feedback!")
+                    .font(.subheadline)
+                    .fontWeight(.medium)
+
+                if let rating = self.selectedRating {
+                    HStack(spacing: 4) {
+                        ForEach(1...5, id: \.self) { star in
+                            Image(systemName: star <= rating ? "star.fill" : "star")
+                                .font(.caption2)
+                                .foregroundStyle(star <= rating ? .yellow : Color(nsColor: .tertiaryLabelColor))
+                        }
+                    }
+                }
+            }
+
+            Spacer()
+        }
+        .padding(.vertical, RunicSpacing.xxs)
+    }
+
+    // MARK: - Error View
+
+    private func errorView(_ message: String) -> some View {
+        HStack(spacing: RunicSpacing.xs) {
+            Image(systemName: "exclamationmark.triangle.fill")
+                .font(.caption)
+                .foregroundStyle(.red)
+
+            Text(message)
+                .font(.caption)
+                .foregroundStyle(.red)
+                .lineLimit(2)
+
+            Spacer()
+
+            Button("Retry") {
+                Task {
+                    await self.submitRating()
+                }
+            }
+            .font(.caption)
+        }
+        .padding(RunicSpacing.xs)
+        .background(Color.red.opacity(0.1))
+        .clipShape(RoundedRectangle(cornerRadius: 6))
+    }
+
+    // MARK: - Submit Logic
+
+    private func submitRating() async {
+        guard let rating = self.selectedRating else { return }
+
+        self.isSubmitting = true
+        self.errorMessage = nil
+
+        do {
+            let trimmedComment = self.comment.trimmingCharacters(in: .whitespacesAndNewlines)
+            let finalComment = trimmedComment.isEmpty ? nil : trimmedComment
+
+            await self.model.onSubmit(rating, finalComment)
+
+            withAnimation(.easeInOut(duration: 0.3)) {
+                self.didSubmit = true
+            }
+        } catch {
+            self.errorMessage = "Failed to submit rating. Please try again."
+        }
+
+        self.isSubmitting = false
+    }
+}