@sriinnu/runic 2.0.0 → 2.11.2

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

@@ -1,29 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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: "Integrations"
-            case .teams: "Teams"
-            }
-        }
-
-        var icon: String {
-            switch self {
-            case .integrations: "link"
-            case .teams: "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

@@ -1,213 +0,0 @@
-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: "Built-in"
-            case .custom: "Custom"
-            }
-        }
-    }
-
-    enum PerformanceSubSection: String, CaseIterable, Identifiable {
-        case monitoring
-        case refresh
-
-        var id: String {
-            self.rawValue
-        }
-
-        var label: String {
-            switch self {
-            case .monitoring: "Monitoring"
-            case .refresh: "Refresh & Safety"
-            }
-        }
-    }
-
-    enum AboutSubSection: String, CaseIterable, Identifiable {
-        case about
-        case help
-
-        var id: String {
-            self.rawValue
-        }
-
-        var label: String {
-            switch self {
-            case .about: "About"
-            case .help: "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)
-            }
-        }
-        .runicTypography()
-        .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

@@ -1,238 +0,0 @@
-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)
-                }
-            }
-        }
-        .runicTypography()
-        .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(RunicFont.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(RunicFont.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(RunicFont.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(RunicFont.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(RunicFont.title3)
-                .foregroundStyle(.green)
-
-            VStack(alignment: .leading, spacing: 2) {
-                Text("Thank you for your feedback!")
-                    .font(RunicFont.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(RunicFont.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(RunicFont.caption)
-                .foregroundStyle(.red)
-
-            Text(message)
-                .font(RunicFont.caption)
-                .foregroundStyle(.red)
-                .lineLimit(2)
-
-            Spacer()
-
-            Button("Retry") {
-                Task {
-                    await self.submitRating()
-                }
-            }
-            .font(RunicFont.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
-    }
-}