@sriinnu/runic 1.0.0

package/Sources/Runic/Views/Menu/MenuContent.swift

@@ -0,0 +1,150 @@
+import AppKit
+import RunicCore
+import SwiftUI
+
+enum MenuContentMetrics {
+    /// Horizontal padding for menu content
+    static let horizontalPadding: CGFloat = RunicSpacing.sm  // 12
+
+    /// Vertical padding for menu content
+    static let verticalPadding: CGFloat = RunicSpacing.xs  // 8
+
+    /// Spacing between menu sections
+    static let sectionSpacing: CGFloat = RunicSpacing.xs  // 8
+
+    /// Spacing between menu entries
+    static let entrySpacing: CGFloat = RunicSpacing.xxs  // 4
+
+    /// Minimum menu width
+    static let minWidth: CGFloat = 260
+}
+
+@MainActor
+struct MenuContent: View {
+    @Bindable var store: UsageStore
+    @Bindable var settings: SettingsStore
+    let account: AccountInfo
+    let updater: UpdaterProviding
+    let provider: UsageProvider?
+    let actions: MenuActions
+
+    var body: some View {
+        let descriptor = MenuDescriptor.build(
+            provider: self.provider,
+            store: self.store,
+            settings: self.settings,
+            account: self.account,
+            updateReady: self.updater.updateStatus.isUpdateReady)
+
+        VStack(alignment: .leading, spacing: MenuContentMetrics.sectionSpacing) {
+            ForEach(Array(descriptor.sections.enumerated()), id: \.offset) { index, section in
+                VStack(alignment: .leading, spacing: MenuContentMetrics.entrySpacing) {
+                    ForEach(Array(section.entries.enumerated()), id: \.offset) { _, entry in
+                        self.row(for: entry)
+                    }
+                }
+                if index < descriptor.sections.count - 1 {
+                    Divider()
+                        .padding(.vertical, RunicSpacing.xxs)
+                }
+            }
+        }
+        .padding(.horizontal, MenuContentMetrics.horizontalPadding)
+        .padding(.vertical, MenuContentMetrics.verticalPadding)
+        .frame(minWidth: MenuContentMetrics.minWidth, alignment: .leading)
+    }
+
+    @ViewBuilder
+    private func row(for entry: MenuDescriptor.Entry) -> some View {
+        switch entry {
+        case let .text(text, style):
+            switch style {
+            case .headline:
+                Text(text).font(.headline)
+            case .primary:
+                Text(text)
+            case .secondary:
+                Text(text).foregroundStyle(.secondary).font(.footnote)
+            }
+        case let .action(title, action):
+            Button {
+                self.perform(action)
+            } label: {
+                if let icon = self.iconName(for: action) {
+                    HStack(spacing: 8) {
+                        Image(systemName: icon)
+                            .imageScale(.medium)
+                            .frame(width: 18, alignment: .center)
+                        Text(title)
+                    }
+                    .foregroundStyle(.primary)
+                } else {
+                    Text(title)
+                }
+            }
+            .buttonStyle(.plain)
+        case .divider:
+            Divider()
+                .padding(.vertical, RunicSpacing.xxs)
+        }
+    }
+
+    private func iconName(for action: MenuDescriptor.MenuAction) -> String? { action.systemImageName }
+
+    private func perform(_ action: MenuDescriptor.MenuAction) {
+        switch action {
+        case .refresh:
+            self.actions.refresh()
+        case .installUpdate:
+            self.actions.installUpdate()
+        case .dashboard:
+            self.actions.openDashboard()
+        case .statusPage:
+            self.actions.openStatusPage()
+        case let .switchAccount(provider):
+            self.actions.switchAccount(provider)
+        case .settings:
+            self.actions.openSettings()
+        case .about:
+            self.actions.openAbout()
+        case .quit:
+            self.actions.quit()
+        case let .copyError(message):
+            self.actions.copyError(message)
+        }
+    }
+}
+
+struct MenuActions {
+    let installUpdate: () -> Void
+    let refresh: () -> Void
+    let openDashboard: () -> Void
+    let openStatusPage: () -> Void
+    let switchAccount: (UsageProvider) -> Void
+    let openSettings: () -> Void
+    let openAbout: () -> Void
+    let quit: () -> Void
+    let copyError: (String) -> Void
+}
+
+@MainActor
+struct StatusIconView: View {
+    @Bindable var store: UsageStore
+    let provider: UsageProvider
+
+    var body: some View {
+        Image(nsImage: self.icon)
+            .renderingMode(.template)
+            .interpolation(.none)
+    }
+
+    private var icon: NSImage {
+        IconRenderer.makeIcon(
+            primaryRemaining: self.store.snapshot(for: self.provider)?.primary.remainingPercent,
+            weeklyRemaining: self.store.snapshot(for: self.provider)?.secondary?.remainingPercent,
+            creditsRemaining: self.provider == .codex ? self.store.credits?.remaining : nil,
+            stale: self.store.isStale(provider: self.provider),
+            style: self.store.style(for: self.provider),
+            statusIndicator: self.store.statusIndicator(for: self.provider))
+    }
+}

package/Sources/Runic/Views/Menu/MenuDescriptor.swift

@@ -0,0 +1,369 @@
+import RunicCore
+import Foundation
+
+@MainActor
+struct MenuDescriptor {
+    struct Section {
+        var entries: [Entry]
+    }
+
+    enum Entry {
+        case text(String, TextStyle)
+        case action(String, MenuAction)
+        case divider
+    }
+
+    enum MenuActionSystemImage: String {
+        case refresh = "arrow.clockwise"
+        case dashboard = "chart.bar"
+        case statusPage = "waveform.path.ecg"
+        case switchAccount = "key"
+        case settings = "gearshape"
+        case about = "info.circle"
+        case quit = "xmark.rectangle"
+        case copyError = "doc.on.doc"
+    }
+
+    enum TextStyle {
+        case headline
+        case primary
+        case secondary
+    }
+
+    enum MenuAction {
+        case installUpdate
+        case refresh
+        case dashboard
+        case statusPage
+        case switchAccount(UsageProvider)
+        case settings
+        case about
+        case quit
+        case copyError(String)
+    }
+
+    var sections: [Section]
+
+    static func build(
+        provider: UsageProvider?,
+        store: UsageStore,
+        settings: SettingsStore,
+        account: AccountInfo,
+        updateReady: Bool) -> MenuDescriptor
+    {
+        var sections: [Section] = []
+
+        switch provider {
+        case .codex?:
+            sections.append(Self.usageSection(for: .codex, store: store, settings: settings))
+            if let accountSection = Self.accountSection(for: .codex, store: store, account: account) {
+                sections.append(accountSection)
+            }
+        case .claude?:
+            sections.append(Self.usageSection(for: .claude, store: store, settings: settings))
+            if let accountSection = Self.accountSection(for: .claude, store: store, account: account) {
+                sections.append(accountSection)
+            }
+        case let provider?:
+            sections.append(Self.usageSection(for: provider, store: store, settings: settings))
+            if let accountSection = Self.accountSection(for: provider, store: store, account: account) {
+                sections.append(accountSection)
+            }
+        case nil:
+            var addedUsage = false
+
+            for enabledProvider in store.enabledProviders() {
+                sections.append(Self.usageSection(for: enabledProvider, store: store, settings: settings))
+                addedUsage = true
+            }
+            if addedUsage {
+                if let accountProvider = Self.accountProviderForCombined(store: store),
+                   let accountSection = Self.accountSection(for: accountProvider, store: store, account: account)
+                {
+                    sections.append(accountSection)
+                }
+            } else {
+                sections.append(Section(entries: [.text("No usage configured.", .secondary)]))
+            }
+        }
+
+        let actions = Self.actionsSection(for: provider, store: store, settings: settings, account: account)
+        if !actions.entries.isEmpty {
+            sections.append(actions)
+        }
+        sections.append(Self.metaSection(updateReady: updateReady))
+
+        return MenuDescriptor(sections: sections)
+    }
+
+    private static func usageSection(
+        for provider: UsageProvider,
+        store: UsageStore,
+        settings: SettingsStore) -> Section
+    {
+        let meta = store.metadata(for: provider)
+        var entries: [Entry] = []
+        let headlineText: String = {
+            if let ver = Self.versionNumber(for: provider, store: store) { return "\(meta.displayName) \(ver)" }
+            return meta.displayName
+        }()
+        entries.append(.text(headlineText, .headline))
+
+        if let snap = store.snapshot(for: provider) {
+            Self.appendRateWindow(entries: &entries, title: meta.sessionLabel, window: snap.primary)
+            if let weekly = snap.secondary {
+                Self.appendRateWindow(entries: &entries, title: meta.weeklyLabel, window: weekly)
+                if let paceText = UsagePaceText.weekly(provider: provider, window: weekly) {
+                    entries.append(.text(paceText, .secondary))
+                }
+            } else if provider == .claude {
+                entries.append(.text("Weekly usage unavailable for this account.", .secondary))
+            }
+            if meta.supportsOpus, let opus = snap.tertiary {
+                Self.appendRateWindow(entries: &entries, title: meta.opusLabel ?? "Sonnet", window: opus)
+            }
+
+            if settings.showOptionalCreditsAndExtraUsage,
+               provider == .claude,
+               let cost = snap.providerCost
+            {
+                let used = UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
+                let limit = UsageFormatter.currencyString(cost.limit, currencyCode: cost.currencyCode)
+                entries.append(.text("Extra usage: \(used) / \(limit)", .primary))
+            }
+
+            if provider == .cursor, let cost = snap.providerCost {
+                let used = UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
+                if cost.limit > 0 {
+                    let limitStr = UsageFormatter.currencyString(cost.limit, currencyCode: cost.currencyCode)
+                    entries.append(.text("On-Demand: \(used) / \(limitStr)", .primary))
+                } else {
+                    entries.append(.text("On-Demand: \(used)", .primary))
+                }
+            }
+        } else {
+            entries.append(.text("No usage yet", .secondary))
+        }
+
+        if settings.showOptionalCreditsAndExtraUsage,
+           meta.supportsCredits,
+           provider == .codex
+        {
+            if let credits = store.credits {
+                entries.append(.text("Credits: \(UsageFormatter.creditsString(from: credits.remaining))", .primary))
+                if let latest = credits.events.first {
+                    entries.append(.text("Last spend: \(UsageFormatter.creditEventSummary(latest))", .secondary))
+                }
+            } else {
+                let hint = store.lastCreditsError ?? meta.creditsHint
+                entries.append(.text(hint, .secondary))
+            }
+        }
+
+        return Section(entries: entries)
+    }
+
+    private static func accountSection(
+        for provider: UsageProvider,
+        store: UsageStore,
+        account: AccountInfo) -> Section?
+    {
+        let snapshot = store.snapshot(for: provider)
+        let metadata = store.metadata(for: provider)
+        let entries = Self.accountEntries(
+            provider: provider,
+            snapshot: snapshot,
+            metadata: metadata,
+            fallback: account)
+        guard !entries.isEmpty else { return nil }
+        return Section(entries: entries)
+    }
+
+    private static func accountEntries(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot?,
+        metadata: ProviderMetadata,
+        fallback: AccountInfo) -> [Entry]
+    {
+        var entries: [Entry] = []
+        let emailText = snapshot?.accountEmail(for: provider)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        let planText = snapshot?.loginMethod(for: provider)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+
+        if let emailText, !emailText.isEmpty {
+            entries.append(.text("Account: \(emailText)", .secondary))
+        }
+        if let planText, !planText.isEmpty {
+            entries.append(.text("Plan: \(AccountFormatter.plan(planText))", .secondary))
+        }
+
+        if metadata.usesAccountFallback {
+            if emailText?.isEmpty ?? true, let fallbackEmail = fallback.email, !fallbackEmail.isEmpty {
+                entries.append(.text("Account: \(fallbackEmail)", .secondary))
+            }
+            if planText?.isEmpty ?? true, let fallbackPlan = fallback.plan, !fallbackPlan.isEmpty {
+                entries.append(.text("Plan: \(AccountFormatter.plan(fallbackPlan))", .secondary))
+            }
+        }
+
+        return entries
+    }
+
+    private static func accountProviderForCombined(store: UsageStore) -> UsageProvider? {
+        for provider in store.enabledProviders() {
+            let metadata = store.metadata(for: provider)
+            if store.snapshot(for: provider)?.identity(for: provider) != nil {
+                return provider
+            }
+            if metadata.usesAccountFallback {
+                return provider
+            }
+        }
+        return nil
+    }
+
+    private static func actionsSection(
+        for provider: UsageProvider?,
+        store: UsageStore,
+        settings: SettingsStore,
+        account: AccountInfo) -> Section
+    {
+        var entries: [Entry] = []
+        let targetProvider = provider ?? store.enabledProviders().first
+        let metadata = targetProvider.map { store.metadata(for: $0) }
+
+        // Show "Add Account" if no account, "Switch Account" if logged in
+        if let targetProvider,
+           ProviderCatalog.implementation(for: targetProvider)?.supportsLoginFlow == true
+        {
+            let loginAction = self.switchAccountTarget(for: provider, store: store)
+            let hasAccount = self.hasAccount(for: provider, store: store, account: account)
+            let accountLabel = hasAccount ? "Switch Account..." : "Add Account..."
+            entries.append(.action(accountLabel, loginAction))
+        }
+
+        entries.append(.action("Ping now", .refresh))
+        if let refreshLine = store.autoRefreshStatusLine() {
+            entries.append(.text(refreshLine, .secondary))
+        }
+        if let lastRefreshLine = store.lastRefreshStatusLine() {
+            entries.append(.text(lastRefreshLine, .secondary))
+        }
+
+        if metadata?.dashboardURL != nil {
+            entries.append(.action("Usage Dashboard", .dashboard))
+        }
+        if metadata?.statusPageURL != nil || metadata?.statusLinkURL != nil {
+            entries.append(.action("Status Page", .statusPage))
+        }
+
+        if let statusLine = self.statusLine(for: provider, store: store) {
+            entries.append(.text(statusLine, .secondary))
+        }
+
+        return Section(entries: entries)
+    }
+
+    private static func metaSection(updateReady: Bool) -> Section {
+        var entries: [Entry] = []
+        if updateReady {
+            entries.append(.action("Update ready, restart now?", .installUpdate))
+        }
+        entries.append(contentsOf: [
+            .action("Settings...", .settings),
+            .action("About Runic", .about),
+            .action("Quit", .quit),
+        ])
+        return Section(entries: entries)
+    }
+
+    private static func statusLine(for provider: UsageProvider?, store: UsageStore) -> String? {
+        let target = provider ?? store.enabledProviders().first
+        guard let target,
+              let status = store.status(for: target),
+              status.indicator != .none else { return nil }
+
+        let description = status.description?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let label = description?.isEmpty == false ? description! : status.indicator.label
+        if let updated = status.updatedAt {
+            let freshness = UsageFormatter.updatedString(from: updated)
+            return "\(label) — \(freshness)"
+        }
+        return label
+    }
+
+    private static func switchAccountTarget(for provider: UsageProvider?, store: UsageStore) -> MenuAction {
+        if let provider { return .switchAccount(provider) }
+        if let enabled = store.enabledProviders().first { return .switchAccount(enabled) }
+        return .switchAccount(.codex)
+    }
+
+    private static func hasAccount(for provider: UsageProvider?, store: UsageStore, account: AccountInfo) -> Bool {
+        let target = provider ?? store.enabledProviders().first ?? .codex
+        if let email = store.snapshot(for: target)?.accountEmail(for: target),
+           !email.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            return true
+        }
+        let metadata = store.metadata(for: target)
+        if metadata.usesAccountFallback,
+           let fallback = account.email?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !fallback.isEmpty
+        {
+            return true
+        }
+        return false
+    }
+
+    private static func appendRateWindow(entries: inout [Entry], title: String, window: RateWindow) {
+        let line = UsageFormatter
+            .usageLine(remaining: window.remainingPercent, used: window.usedPercent)
+        entries.append(.text("\(title): \(line)", .primary))
+        if let date = window.resetsAt {
+            let countdown = UsageFormatter.resetCountdownDescription(from: date)
+            entries.append(.text("Resets \(countdown)", .secondary))
+        } else if let reset = window.resetDescription {
+            entries.append(.text(Self.resetLine(reset), .secondary))
+        }
+    }
+
+    private static func resetLine(_ reset: String) -> String {
+        let trimmed = reset.trimmingCharacters(in: .whitespacesAndNewlines)
+        if trimmed.lowercased().hasPrefix("resets") { return trimmed }
+        return "Resets \(trimmed)"
+    }
+
+    private static func versionNumber(for provider: UsageProvider, store: UsageStore) -> String? {
+        guard let raw = store.version(for: provider) else { return nil }
+        let pattern = #"[0-9]+(?:\.[0-9]+)*"#
+        guard let regex = try? NSRegularExpression(pattern: pattern) else { return nil }
+        let range = NSRange(raw.startIndex..<raw.endIndex, in: raw)
+        guard let match = regex.firstMatch(in: raw, options: [], range: range),
+              let r = Range(match.range, in: raw) else { return nil }
+        return String(raw[r])
+    }
+}
+
+private enum AccountFormatter {
+    static func plan(_ text: String) -> String {
+        let cleaned = UsageFormatter.cleanPlanName(text)
+        return cleaned.isEmpty ? text : cleaned
+    }
+
+    static func email(_ text: String) -> String { text }
+}
+
+extension MenuDescriptor.MenuAction {
+    var systemImageName: String? {
+        switch self {
+        case .installUpdate, .settings, .about, .quit:
+            nil
+        case .refresh: MenuDescriptor.MenuActionSystemImage.refresh.rawValue
+        case .dashboard: MenuDescriptor.MenuActionSystemImage.dashboard.rawValue
+        case .statusPage: MenuDescriptor.MenuActionSystemImage.statusPage.rawValue
+        case .switchAccount: MenuDescriptor.MenuActionSystemImage.switchAccount.rawValue
+        case .copyError: MenuDescriptor.MenuActionSystemImage.copyError.rawValue
+        }
+    }
+}

package/Sources/Runic/Views/Menu/MenuHighlightStyle.swift

@@ -0,0 +1,42 @@
+import SwiftUI
+
+private struct MenuItemHighlightedKey: EnvironmentKey {
+    static let defaultValue = false
+}
+
+extension EnvironmentValues {
+    var menuItemHighlighted: Bool {
+        get { self[MenuItemHighlightedKey.self] }
+        set { self[MenuItemHighlightedKey.self] = newValue }
+    }
+}
+
+enum MenuHighlightStyle {
+    static let selectionText = Color(nsColor: .selectedMenuItemTextColor)
+    static let normalPrimaryText = Color(nsColor: .controlTextColor)
+    static let normalSecondaryText = Color(nsColor: .secondaryLabelColor)
+
+    static func primary(_ highlighted: Bool) -> Color {
+        highlighted ? self.selectionText : self.normalPrimaryText
+    }
+
+    static func secondary(_ highlighted: Bool) -> Color {
+        highlighted ? self.selectionText : self.normalSecondaryText
+    }
+
+    static func error(_ highlighted: Bool) -> Color {
+        highlighted ? self.selectionText : Color(nsColor: .systemRed)
+    }
+
+    static func progressTrack(_ highlighted: Bool) -> Color {
+        highlighted ? self.selectionText.opacity(0.22) : Color(nsColor: .tertiaryLabelColor).opacity(0.22)
+    }
+
+    static func progressTint(_ highlighted: Bool, fallback: Color) -> Color {
+        highlighted ? self.selectionText : fallback
+    }
+
+    static func selectionBackground(_ highlighted: Bool) -> Color {
+        highlighted ? Color(nsColor: .selectedContentBackgroundColor) : .clear
+    }
+}