@sriinnu/runic 2.0.0 → 2.11.2

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

@@ -1,214 +0,0 @@
-import Charts
-import RunicCore
-import SwiftUI
-
-@MainActor
-struct ProjectBreakdownMenuView: View {
-    private let breakdown: [UsageLedgerProjectSummary]
-    private let width: CGFloat
-
-    /// Maximum number of projects to show before truncating with "and N more".
-    private static let maxDisplayed = 8
-
-    init(breakdown: [UsageLedgerProjectSummary], width: CGFloat) {
-        self.breakdown = breakdown
-        self.width = width
-    }
-
-    var body: some View {
-        let model = Self.makeModel(from: self.breakdown)
-        VStack(alignment: .leading, spacing: RunicSpacing.sm) {
-            if model.items.isEmpty {
-                Text("No project data.")
-                    .font(RunicFont.footnote)
-                    .foregroundStyle(.secondary)
-            } else {
-                // MARK: - Title
-
-                Text("Projects")
-                    .font(RunicFont.caption)
-                    .fontWeight(.semibold)
-                    .foregroundStyle(.primary)
-
-                // MARK: - Horizontal bar chart
-
-                Chart {
-                    ForEach(model.chartItems) { item in
-                        BarMark(
-                            x: .value("Tokens", item.totalTokens),
-                            y: .value("Project", item.name))
-                            .foregroundStyle(item.color)
-                            .cornerRadius(RunicCornerRadius.xs)
-                    }
-                }
-                .chartXAxis(.hidden)
-                .chartYAxis {
-                    AxisMarks { _ in
-                        AxisValueLabel()
-                            .font(RunicFont.caption2)
-                            .foregroundStyle(Color(nsColor: .secondaryLabelColor))
-                    }
-                }
-                .chartLegend(.hidden)
-                .frame(height: Self.chartHeight(itemCount: model.chartItems.count))
-                .accessibilityElement(children: .ignore)
-                .accessibilityLabel(Self.chartAccessibilityLabel(model: model))
-
-                // MARK: - Project list
-
-                VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
-                    ForEach(model.chartItems) { item in
-                        Self.projectRow(item: item)
-                    }
-                }
-
-                // MARK: - Overflow note
-
-                if model.overflowCount > 0 {
-                    Text("and \(model.overflowCount) more")
-                        .font(RunicFont.caption2)
-                        .foregroundStyle(.tertiary)
-                }
-
-                // MARK: - Total summary
-
-                Divider()
-                Self.totalRow(model: model)
-            }
-        }
-        .padding(.horizontal, MenuCardMetrics.horizontalPadding)
-        .padding(.vertical, RunicSpacing.xs)
-        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
-    }
-
-    // MARK: - Row views
-
-    private static func projectRow(item: ProjectItem) -> some View {
-        HStack(spacing: RunicSpacing.xxs) {
-            Circle()
-                .fill(item.color)
-                .frame(width: RunicSpacing.chartLegendDot, height: RunicSpacing.chartLegendDot)
-            Text(item.name)
-                .font(RunicFont.caption)
-                .foregroundStyle(.primary)
-                .lineLimit(1)
-                .truncationMode(.middle)
-            Spacer(minLength: RunicSpacing.xxs)
-            VStack(alignment: .trailing, spacing: 0) {
-                Text("\(UsageFormatter.tokenCountString(item.totalTokens)) tokens")
-                    .font(RunicFont.caption2)
-                    .foregroundStyle(.secondary)
-                HStack(spacing: RunicSpacing.xxxs) {
-                    if let cost = item.costText {
-                        Text(cost)
-                            .font(RunicFont.caption2)
-                            .foregroundStyle(.tertiary)
-                    }
-                    if item.modelCount > 0 {
-                        Text("\(item.modelCount) model\(item.modelCount == 1 ? "" : "s")")
-                            .font(RunicFont.caption2)
-                            .foregroundStyle(.tertiary)
-                    }
-                }
-            }
-        }
-    }
-
-    private static func totalRow(model: ProjectModel) -> some View {
-        HStack {
-            Text("Total")
-                .font(RunicFont.caption)
-                .fontWeight(.medium)
-                .foregroundStyle(.primary)
-            Spacer(minLength: RunicSpacing.xxs)
-            VStack(alignment: .trailing, spacing: 0) {
-                Text("\(UsageFormatter.tokenCountString(model.grandTotalTokens)) tokens")
-                    .font(RunicFont.caption2)
-                    .foregroundStyle(.secondary)
-                if let cost = model.grandTotalCostText {
-                    Text(cost)
-                        .font(RunicFont.caption2)
-                        .foregroundStyle(.tertiary)
-                }
-            }
-        }
-    }
-
-    // MARK: - Chart height
-
-    private static func chartHeight(itemCount: Int) -> CGFloat {
-        // ~24pt per bar, minimum 60pt
-        max(60, CGFloat(itemCount) * 24)
-    }
-
-    // MARK: - Model
-
-    struct ProjectItem: Identifiable {
-        let id: String
-        let name: String
-        let totalTokens: Int
-        let costText: String?
-        let modelCount: Int
-        let color: Color
-    }
-
-    struct ProjectModel {
-        let items: [ProjectItem]
-        let chartItems: [ProjectItem]
-        let overflowCount: Int
-        let grandTotalTokens: Int
-        let grandTotalCostText: String?
-    }
-
-    private static func chartAccessibilityLabel(model: ProjectModel) -> String {
-        guard !model.chartItems.isEmpty else { return "Project breakdown chart, no data" }
-
-        let projectCount = model.items.count
-        let totalTokens = UsageFormatter.tokenCountString(model.grandTotalTokens)
-
-        let topItems = model.chartItems.prefix(3).map { item -> String in
-            let pct = model.grandTotalTokens > 0
-                ? Double(item.totalTokens) / Double(model.grandTotalTokens) * 100
-                : 0
-            return "\(item.name) \(String(format: "%.0f", pct))%"
-        }
-
-        var label = "Project breakdown: \(projectCount) project\(projectCount == 1 ? "" : "s"), \(totalTokens) tokens total"
-        if !topItems.isEmpty {
-            label += ", \(topItems.joined(separator: ", "))"
-        }
-        return label
-    }
-
-    private static func makeModel(from breakdown: [UsageLedgerProjectSummary]) -> ProjectModel {
-        let sorted = breakdown.sorted { lhs, rhs in
-            lhs.totals.totalTokens > rhs.totals.totalTokens
-        }
-
-        let items: [ProjectItem] = sorted.enumerated().map { index, summary in
-            let name = summary.displayProjectName
-            let costText = summary.totals.costUSD.map { UsageFormatter.usdString($0) }
-            return ProjectItem(
-                id: "\(name)-\(index)",
-                name: name,
-                totalTokens: summary.totals.totalTokens,
-                costText: costText,
-                modelCount: summary.modelsUsed.count,
-                color: RunicColors.chartColor(at: index))
-        }
-
-        let displayed = Array(items.prefix(self.maxDisplayed))
-        let overflow = max(0, items.count - self.maxDisplayed)
-
-        let grandTokens = sorted.reduce(0) { $0 + $1.totals.totalTokens }
-        let grandCost = sorted.reduce(0.0) { $0 + ($1.totals.costUSD ?? 0) }
-        let grandCostText = grandCost > 0 ? UsageFormatter.usdString(grandCost) : nil
-
-        return ProjectModel(
-            items: items,
-            chartItems: displayed,
-            overflowCount: overflow,
-            grandTotalTokens: grandTokens,
-            grandTotalCostText: grandCostText)
-    }
-}

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

@@ -1,220 +0,0 @@
-import RunicCore
-import SwiftUI
-
-@MainActor
-struct ProjectBudgetMenuView: View {
-    fileprivate struct ProjectUsage: Identifiable {
-        let id: String
-        let projectName: String
-        let budget: ProjectBudgetStore.ProjectBudget
-        let spent: Double
-        let percentUsed: Double
-        let isOverBudget: Bool
-        let isNearLimit: Bool
-
-        var statusColor: Color {
-            if self.isOverBudget {
-                Color(red: 0.94, green: 0.36, blue: 0.36) // Red
-            } else if self.isNearLimit {
-                Color(red: 0.94, green: 0.74, blue: 0.26) // Yellow
-            } else {
-                Color(red: 0.46, green: 0.75, blue: 0.36) // Green
-            }
-        }
-    }
-
-    private let projectSummaries: [UsageLedgerProjectSummary]
-    private let width: CGFloat
-    private let onOpenPreferences: () -> Void
-
-    @State private var hoveredProjectID: String?
-
-    init(
-        projectSummaries: [UsageLedgerProjectSummary],
-        width: CGFloat,
-        onOpenPreferences: @escaping () -> Void)
-    {
-        self.projectSummaries = projectSummaries
-        self.width = width
-        self.onOpenPreferences = onOpenPreferences
-    }
-
-    var body: some View {
-        let model = Self.makeModel(from: self.projectSummaries)
-        VStack(alignment: .leading, spacing: RunicSpacing.sm) {
-            HStack {
-                Text("Project Budgets")
-                    .font(RunicFont.headline)
-                    .fontWeight(.semibold)
-                Spacer()
-                Button {
-                    self.onOpenPreferences()
-                } label: {
-                    HStack(spacing: RunicSpacing.xxs) {
-                        Image(systemName: "gearshape")
-                            .font(RunicFont.caption)
-                        Text("Configure")
-                            .font(RunicFont.caption)
-                    }
-                }
-                .buttonStyle(.plain)
-                .foregroundStyle(.blue)
-            }
-
-            if model.isEmpty {
-                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                    Text("No budgets configured.")
-                        .font(RunicFont.footnote)
-                        .foregroundStyle(.secondary)
-                    Button {
-                        self.onOpenPreferences()
-                    } label: {
-                        Text("Set up budgets in Preferences")
-                            .font(RunicFont.caption)
-                    }
-                    .buttonStyle(.plain)
-                    .foregroundStyle(.blue)
-                }
-            } else {
-                VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-                    ForEach(model) { project in
-                        ProjectBudgetRow(
-                            project: project,
-                            isHovered: self.hoveredProjectID == project.id)
-                            .onHover { hovering in
-                                self.hoveredProjectID = hovering ? project.id : nil
-                            }
-                    }
-                }
-
-                // Summary
-                let overBudget = model.count(where: { $0.isOverBudget })
-                let nearLimit = model.count(where: { $0.isNearLimit && !$0.isOverBudget })
-                if overBudget > 0 || nearLimit > 0 {
-                    Divider()
-                        .padding(.vertical, RunicSpacing.xxs)
-
-                    VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
-                        if overBudget > 0 {
-                            HStack(spacing: RunicSpacing.xxs) {
-                                Image(systemName: "exclamationmark.triangle.fill")
-                                    .font(RunicFont.caption2)
-                                    .foregroundStyle(Color(red: 0.94, green: 0.36, blue: 0.36))
-                                Text("\(overBudget) project\(overBudget == 1 ? "" : "s") over budget")
-                                    .font(RunicFont.caption)
-                                    .foregroundStyle(.secondary)
-                            }
-                        }
-                        if nearLimit > 0 {
-                            HStack(spacing: RunicSpacing.xxs) {
-                                Image(systemName: "exclamationmark.circle.fill")
-                                    .font(RunicFont.caption2)
-                                    .foregroundStyle(Color(red: 0.94, green: 0.74, blue: 0.26))
-                                Text("\(nearLimit) project\(nearLimit == 1 ? "" : "s") near limit")
-                                    .font(RunicFont.caption)
-                                    .foregroundStyle(.secondary)
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        .padding(.horizontal, MenuCardMetrics.horizontalPadding)
-        .padding(.vertical, RunicSpacing.xs)
-        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
-    }
-
-    private static func makeModel(from summaries: [UsageLedgerProjectSummary]) -> [ProjectUsage] {
-        let budgets = ProjectBudgetStore.getAllBudgets()
-
-        var result: [ProjectUsage] = []
-
-        for budget in budgets where budget.enabled {
-            let projectID = budget.projectID
-            let summary = summaries.first { $0.projectID == projectID }
-            let spent = summary?.totals.costUSD ?? 0.0
-            let percentUsed = budget.monthlyLimit > 0 ? (spent / budget.monthlyLimit) * 100 : 0
-            let isOverBudget = percentUsed > 100
-            let isNearLimit = percentUsed >= (budget.alertThreshold * 100)
-
-            result.append(ProjectUsage(
-                id: projectID,
-                projectName: budget.projectName ?? projectID,
-                budget: budget,
-                spent: spent,
-                percentUsed: min(100, percentUsed),
-                isOverBudget: isOverBudget,
-                isNearLimit: isNearLimit))
-        }
-
-        return result.sorted { lhs, rhs in
-            if lhs.isOverBudget != rhs.isOverBudget {
-                return lhs.isOverBudget
-            }
-            if lhs.isNearLimit != rhs.isNearLimit {
-                return lhs.isNearLimit
-            }
-            return lhs.percentUsed > rhs.percentUsed
-        }
-    }
-}
-
-private struct ProjectBudgetRow: View {
-    let project: ProjectBudgetMenuView.ProjectUsage
-    let isHovered: Bool
-    @Environment(\.menuItemHighlighted) private var isHighlighted
-
-    var body: some View {
-        VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
-            HStack(alignment: .firstTextBaseline) {
-                Text(self.project.projectName)
-                    .font(RunicFont.body)
-                    .fontWeight(.medium)
-                    .lineLimit(1)
-                Spacer()
-                Text(self.budgetText)
-                    .font(RunicFont.caption)
-                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
-            }
-
-            UsageProgressBar(
-                percent: self.project.percentUsed,
-                tint: self.project.statusColor,
-                accessibilityLabel: "Budget usage")
-
-            HStack(alignment: .firstTextBaseline) {
-                Text(String(format: "%.0f%%", self.project.percentUsed))
-                    .font(RunicFont.caption)
-                    .foregroundStyle(self.statusTextColor)
-                Spacer()
-                if self.project.isOverBudget {
-                    Text("Over budget")
-                        .font(RunicFont.caption)
-                        .foregroundStyle(Color(red: 0.94, green: 0.36, blue: 0.36))
-                        .fontWeight(.medium)
-                } else if self.project.isNearLimit {
-                    Text("Near limit")
-                        .font(RunicFont.caption)
-                        .foregroundStyle(Color(red: 0.94, green: 0.74, blue: 0.26))
-                        .fontWeight(.medium)
-                }
-            }
-        }
-        .padding(RunicSpacing.xs)
-        .background {
-            RoundedRectangle(cornerRadius: RunicCornerRadius.sm, style: .continuous)
-                .fill(self.isHovered ? Color(nsColor: .separatorColor).opacity(0.15) : Color.clear)
-        }
-    }
-
-    private var budgetText: String {
-        "\(UsageFormatter.usdString(self.project.spent)) / \(UsageFormatter.usdString(self.project.budget.monthlyLimit))"
-    }
-
-    private var statusTextColor: Color {
-        if self.isHighlighted {
-            return MenuHighlightStyle.selectionText
-        }
-        return self.project.statusColor
-    }
-}

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

@@ -1,86 +0,0 @@
-import AppKit
-import RunicCore
-import SwiftUI
-
-/// Horizontal provider tab bar at the top of the menu dropdown — inspired by CodexBar.
-/// Uses actual provider brand icons (SVG) with brand colors from the descriptor registry.
-@MainActor
-struct ProviderTabBarView: View {
-    struct TabItem: Identifiable {
-        let id: String
-        let label: String
-        let icon: NSImage?
-        let provider: UsageProvider?
-        let isSelected: Bool
-        let brandColor: Color
-    }
-
-    let tabs: [TabItem]
-    let width: CGFloat
-    let onSelect: (UsageProvider?) -> Void
-
-    var body: some View {
-        ScrollView(.horizontal, showsIndicators: false) {
-            HStack(spacing: RunicSpacing.compact) {
-                ForEach(self.tabs) { tab in
-                    Button {
-                        self.onSelect(tab.provider)
-                    } label: {
-                        HStack(spacing: RunicSpacing.xxs) {
-                            if let nsImage = tab.icon {
-                                Image(nsImage: nsImage)
-                                    .resizable()
-                                    .aspectRatio(contentMode: .fit)
-                                    .frame(width: 18, height: 18)
-                            } else if tab.provider == nil {
-                                Image(systemName: "square.grid.2x2")
-                                    .font(.system(size: 14, weight: .medium))
-                            }
-                            Text(tab.label)
-                                .font(RunicFont.caption)
-                                .fontWeight(tab.isSelected ? .semibold : .regular)
-                                .lineLimit(1)
-                        }
-                        .padding(.horizontal, RunicSpacing.xs + 2)
-                        .padding(.vertical, RunicSpacing.xxs + 2)
-                        .background(
-                            Capsule(style: .continuous)
-                                .fill(tab.isSelected
-                                    ? tab.brandColor.opacity(RunicColors.Opacity.medium)
-                                    : Color(nsColor: .controlBackgroundColor).opacity(RunicColors.Opacity.subtle)))
-                        .overlay(
-                            Capsule(style: .continuous)
-                                .stroke(
-                                    tab.isSelected
-                                        ? tab.brandColor.opacity(RunicColors.Opacity.strong)
-                                        : Color(nsColor: .separatorColor).opacity(RunicColors.Opacity.light),
-                                    lineWidth: 0.5))
-                        .foregroundStyle(tab.isSelected ? tab.brandColor : .secondary)
-                        .shadow(
-                            color: tab.isSelected ? tab.brandColor.opacity(0.15) : .clear,
-                            radius: 4, y: 1)
-                    }
-                    .buttonStyle(TabButtonStyle())
-                }
-            }
-            .padding(.horizontal, MenuCardMetrics.horizontalPadding)
-            .padding(.vertical, RunicSpacing.xs)
-        }
-        .frame(minWidth: self.width, maxWidth: .infinity)
-        .accessibilityElement(children: .contain)
-        .accessibilityLabel("Provider tabs")
-    }
-}
-
-/// Button style with subtle hover scale feedback.
-private struct TabButtonStyle: ButtonStyle {
-    @State private var isHovered = false
-
-    func makeBody(configuration: Configuration) -> some View {
-        configuration.label
-            .scaleEffect(configuration.isPressed ? 0.95 : (self.isHovered ? 1.03 : 1.0))
-            .animation(RunicAnimation.hoverFeedback, value: configuration.isPressed)
-            .animation(RunicAnimation.hoverFeedback, value: self.isHovered)
-            .onHover { self.isHovered = $0 }
-    }
-}