Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

24.0 KB
Raw Blame
import AppKit
import Combine
import SwiftUI

struct MeetingSummaryView: View {
    var session: MeetingSession? = nil
    var isQuiescent = true
    @Environment(\.theme) private var theme
    @ObservedObject private var settings = SettingsStore.shared
    @StateObject private var preferences = MeetingSummaryPreferences()
    @StateObject private var controller = MeetingSummaryController()
    @State private var kind = MeetingSummaryKind.executive
    @State private var catalog: [CommandModelOption] = []
    @State private var catalogLoaded = false
    @State private var route: MeetingSummaryRoute?
    @State private var readinessIssue: String?
    /// The on-device summary model, read when the providers are; nil in builds without one.
    @State private var onDeviceModel: PrivateAIRegisteredModel?
    @State private var confirmDeletion = false
    @State private var showModelPicker = false

    private var refreshID: String {
        // A prompt edit re-checks the saved custom summary, so an older result never stays on screen.
        let prompt = self.kind == .custom
            ? MeetingSummaryInput.fingerprint(self.preferences.customPrompt.trimmingCharacters(in: .whitespacesAndNewlines))
            : ""
        return "\(self.session?.id.uuidString ?? "home")-\(self.session?.updatedAt.timeIntervalSince1970 ?? 0)-\(self.kind.rawValue)-\(prompt)"
    }

    private var providerID: String {
        self.preferences.selection.providerID
    }

    private var providerKey: String {
        ModelRepository.shared.providerKey(for: self.providerID)
    }

    private var providers: [CommandModelOption] {
        var seen = Set<String>()
        return self.catalog.filter { seen.insert($0.providerID).inserted }
    }

    private var usesOnDevice: Bool {
        self.onDeviceModel != nil && self.providerID == MeetingSummaryOnDevice.providerID
    }

    private var hasChoices: Bool {
        !self.catalog.isEmpty || self.onDeviceModel != nil
    }

    private var needsCustomPrompt: Bool {
        self.kind == .custom && self.preferences.customPrompt.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
    }

    private var modelID: String {
        self.preferences.selection.modelsByProvider[self.providerKey] ?? ""
    }

    var body: some View {
        VStack(alignment: .leading, spacing: self.theme.metrics.spacing.lg) {
            self.configurationPanel
            if !self.controller.output.isEmpty {
                self.summaryDocument
            }
        }
        .frame(maxWidth: 960, alignment: .leading)
        .frame(maxWidth: .infinity, alignment: .leading)
        .padding(.vertical, self.theme.metrics.spacing.md)
        .task(id: self.refreshID) {
            if self.kind == .custom {
                // Coalesce typing; a newer keystroke cancels this task before it reads the saved file.
                try? await Task.sleep(for: .milliseconds(250))
                guard !Task.isCancelled else { return }
            }
            await self.controller.refresh(session: self.session, kind: self.kind, customPrompt: self.preferences.customPrompt)
        }
        .task { self.reloadProviders() }
        .onReceive(self.settings.objectWillChange) { _ in
            // SettingsStore publishes before mutating its defaults.
            Task { @MainActor in self.reloadProviders() }
        }
        .onChange(of: self.preferences.selection) { _, _ in self.resolveRoute() }
        .onDisappear { self.controller.cancel() }
        .alert("Delete summary model?", isPresented: self.$confirmDeletion) {
            Button("Cancel", role: .cancel) {}
            Button("Delete", role: .destructive) { self.controller.deleteModel(asr: AppServices.shared.asr) }
        } message: {
            Text("Remove the \(self.downloadSize.map { "\($0) " } ?? "")download from this Mac. Your meetings and saved summaries stay. You can download it again anytime.")
        }
    }

    private var configurationPanel: some View {
        VStack(alignment: .leading, spacing: self.theme.metrics.spacing.md) {
            HStack(alignment: .firstTextBaseline) {
                Text("Your meeting, summed up.")
                    .font(.system(.title3, design: .serif).weight(.medium))
                    .foregroundStyle(self.theme.palette.primaryText)
                    .accessibilityAddTraits(.isHeader)
                Spacer()
                if !self.catalog.isEmpty {
                    Button("Manage providers") { AppNavigationRouter.shared.request(.aiEnhancements) }
                        .buttonStyle(.link)
                        .disabled(self.controller.busy)
                }
            }
            if !self.catalogLoaded {
                ProgressView().controlSize(.small)
            } else if !self.hasChoices {
                self.setupPrompt
            } else {
                // Two equal columns; stacked when the window is narrow.
                ViewThatFits(in: .horizontal) {
                    HStack(alignment: .top, spacing: self.theme.metrics.spacing.md) {
                        self.modelChooser.frame(minWidth: 240)
                        self.kindPicker.frame(minWidth: 200)
                    }
                    VStack(alignment: .leading, spacing: self.theme.metrics.spacing.md) {
                        self.modelChooser
                        self.kindPicker
                    }
                }
                .disabled(self.controller.busy)
                if self.usesOnDevice {
                    self.thinkingRow.disabled(self.controller.busy)
                }
                if self.kind == .custom {
                    self.customPromptEditor
                }
                self.actions
                if self.usesOnDevice, self.controller.downloading {
                    Text(PrivateAIModelDownloadProgressText.detailText(for: self.controller.progress))
                        .font(self.theme.typography.caption)
                        .foregroundStyle(self.theme.palette.secondaryText)
                }
                if let error = self.controller.error ?? self.readinessIssue {
                    Text(error)
                        .font(self.theme.typography.bodySmall)
                        .foregroundStyle(self.theme.palette.warning)
                        .fixedSize(horizontal: false, vertical: true)
                        .textSelection(.enabled)
                }
                if self.session == nil {
                    Text("Open a completed meeting to summarize its transcript.")
                        .font(self.theme.typography.bodySmall)
                        .foregroundStyle(self.theme.palette.secondaryText)
                }
                Label(self.destination, systemImage: self.usesOnDevice ? "lock" : "network")
                    .font(self.theme.typography.caption)
                    .foregroundStyle(self.theme.palette.secondaryText)
            }
        }
        .padding(self.theme.metrics.spacing.lg)
        .background(RoundedRectangle(cornerRadius: 12).fill(self.theme.palette.primaryText.opacity(0.025)))
        .overlay(RoundedRectangle(cornerRadius: 12).strokeBorder(self.theme.palette.primaryText.opacity(0.1)))
    }

    private var setupPrompt: some View {
        VStack(alignment: .leading, spacing: self.theme.metrics.spacing.sm) {
            Text("Summaries use a provider from AI Settings. Add and verify one to summarize this meeting.")
                .font(self.theme.typography.bodySmall)
                .foregroundStyle(self.theme.palette.secondaryText)
                .fixedSize(horizontal: false, vertical: true)
            Button("Set up a provider", systemImage: "gearshape") { AppNavigationRouter.shared.request(.aiEnhancements) }
                .fluidGlassAction(prominent: true)
        }
    }

    private var destination: String {
        if self.usesOnDevice {
            return "Nothing leaves your Mac · Summaries are in English"
        }
        guard let route else { return "Choose a configured provider and model to continue." }
        let host = URL(string: route.baseURL)?.host ?? route.providerName
        return "Transcript sent to \(route.providerName) (\(host)) · Audio stays on your Mac"
    }

    /// Every model a summary can use: the one on this Mac first, then each verified provider's.
    private var modelOptions: [CommandModelOption] {
        guard let onDeviceModel else { return self.catalog }
        // The model's own name stands in for its ID, which is not meant to be read.
        return [CommandModelOption(
            providerID: MeetingSummaryOnDevice.providerID,
            providerName: MeetingSummaryOnDevice.providerName,
            modelID: onDeviceModel.displayName,
            displayName: onDeviceModel.displayName
        )] + self.catalog
    }

    private var selectedOption: CommandModelOption? {
        self.modelOptions.first {
            self.usesOnDevice
                ? $0.providerID == MeetingSummaryOnDevice.providerID
                : ModelRepository.shared.providerKey(for: $0.providerID) == self.providerKey && $0.modelID == self.modelID
        }
    }

    /// One searchable list across providers, the same chooser Command Mode uses.
    private var modelChooser: some View {
        VStack(alignment: .leading, spacing: 6) {
            Text("Model").font(self.theme.typography.caption)
            Button {
                self.showModelPicker.toggle()
            } label: {
                HStack(spacing: self.theme.metrics.spacing.sm) {
                    if let option = self.selectedOption {
                        Text(option.displayName).lineLimit(1).truncationMode(.middle)
                        Text(option.providerName)
                            .foregroundStyle(self.theme.palette.secondaryText)
                            .lineLimit(1)
                    } else {
                        Text("Choose model").foregroundStyle(self.theme.palette.secondaryText)
                    }
                    Spacer(minLength: 0)
                    FluidDropdownChevron()
                }
                .font(self.theme.typography.bodySmall)
                .foregroundStyle(self.theme.palette.primaryText)
                .padding(.horizontal, 12)
                .padding(.vertical, 9)
                .frame(maxWidth: .infinity, alignment: .leading)
                .fluidDropdownSurface()
            }
            .buttonStyle(.plain)
            .help("Search models on this Mac and from verified providers")
            .accessibilityLabel("Summary model")
            .accessibilityValue(self.selectedOption.map { "\($0.displayName), \($0.providerName)" } ?? "None")
            .popover(isPresented: self.$showModelPicker, arrowEdge: .top) {
                CommandModelPicker(
                    options: self.modelOptions,
                    selectedProviderID: self.selectedOption?.providerID ?? "",
                    selectedModelID: self.selectedOption?.modelID ?? "",
                    onSelect: { option in
                        self.selectModel(option)
                        self.showModelPicker = false
                    },
                    onDismiss: { self.showModelPicker = false }
                )
            }
            if self.usesOnDevice, let memoryWarning = self.memoryWarning {
                Label(memoryWarning, systemImage: "exclamationmark.triangle")
                    .font(self.theme.typography.caption)
                    .foregroundStyle(self.theme.palette.warning)
                    .fixedSize(horizontal: false, vertical: true)
            }
        }
    }

    private var memoryWarning: String? {
        MeetingSummaryOnDevice.memoryWarning(
            recommendedMemoryGB: self.onDeviceModel?.recommendedMemoryGB,
            memoryGB: MeetingSummaryOnDevice.thisMacMemoryGB
        )
    }

    private var kindPicker: some View {
        VStack(alignment: .leading, spacing: 6) {
            Text("Summary type").font(self.theme.typography.caption)
            FluidDropdownPicker("Summary type", selectedTitle: self.kind.title, selection: self.$kind) {
                ForEach(MeetingSummaryKind.allCases) { kind in Text(kind.title).tag(kind) }
            }
            .fluidDropdownStyle(fillsWidth: true)
        }
    }

    /// A setting of the model on this Mac, laid out like the rows in Recording settings.
    private var thinkingRow: some View {
        HStack(alignment: .center, spacing: self.theme.metrics.spacing.lg) {
            VStack(alignment: .leading, spacing: self.theme.metrics.spacing.xs) {
                Text("Think first").font(self.theme.typography.bodySmallStrong)
                Text("The model reasons about the transcript before it writes. More careful, a little slower.")
                    .font(self.theme.typography.caption)
                    .foregroundStyle(self.theme.palette.secondaryText)
                    .fixedSize(horizontal: false, vertical: true)
            }
            .frame(maxWidth: .infinity, alignment: .leading)
            Toggle("Think first", isOn: self.$preferences.thinksFirst)
                .labelsHidden()
                .toggleStyle(.switch)
                .accessibilityLabel("Think before summarizing")
        }
    }

    private var downloadSize: String? {
        self.onDeviceModel?.artifact.byteCount.map { ByteCountFormatter.string(fromByteCount: $0, countStyle: .file) }
    }

    private var customPromptEditor: some View {
        VStack(alignment: .leading, spacing: 6) {
            Text("Custom prompt").font(self.theme.typography.caption)
            TextEditor(text: self.$preferences.customPrompt)
                .font(self.theme.typography.body)
                .scrollContentBackground(.hidden)
                .background(DictationTextTarget())
                .padding(self.theme.metrics.spacing.sm)
                .background(self.theme.palette.cardBackground, in: RoundedRectangle(cornerRadius: self.theme.metrics.corners.sm))
                .overlay(alignment: .topLeading) {
                    if self.preferences.customPrompt.isEmpty {
                        Text("For example: Write a short recap email to the client with next steps and owners.")
                            .font(self.theme.typography.body)
                            .foregroundStyle(self.theme.palette.tertiaryText)
                            .padding(self.theme.metrics.spacing.sm)
                            .padding(.leading, 5)
                            .allowsHitTesting(false)
                    }
                }
                .frame(minHeight: 96, maxHeight: 200)
                .disabled(self.controller.busy)
                .accessibilityLabel("Custom summary prompt")
            Text("Saved for every meeting. Replaces the summary type instructions; the transcript is still treated as source material only.")
                .font(self.theme.typography.caption)
                .foregroundStyle(self.theme.palette.secondaryText)
                .fixedSize(horizontal: false, vertical: true)
        }
    }

    private var actions: some View {
        FluidGlassControlGroup {
            HStack(spacing: self.theme.metrics.spacing.sm) {
                if self.controller.checking {
                    ProgressView().controlSize(.small)
                } else if self.controller.generating {
                    ProgressView().controlSize(.small)
                    Text("Summarizing…").font(self.theme.typography.bodySmall)
                    Button("Cancel") { self.controller.cancel() }.fluidGlassAction()
                } else if self.usesOnDevice, self.controller.downloading {
                    Button {} label: {
                        VStack(spacing: 4) {
                            Text(PrivateAIModelDownloadProgressText.buttonTitle(for: self.controller.progress))
                            ProgressView(value: self.controller.progress?.fractionCompleted)
                                .progressViewStyle(.linear)
                                .frame(width: 160)
                                .controlSize(.mini)
                        }
                    }
                    .fluidGlassAction()
                    .disabled(true)
                    Button("Cancel") { self.controller.cancel() }.fluidGlassAction()
                } else if self.usesOnDevice, self.controller.deleting {
                    ProgressView().controlSize(.small)
                    Text("Deleting download…").font(self.theme.typography.bodySmall)
                } else if self.usesOnDevice, !self.controller.installed {
                    Button(self.downloadSize.map { "Download · \($0)" } ?? "Download", systemImage: "arrow.down.circle") {
                        self.controller.download()
                    }
                    .fluidGlassAction(prominent: true)
                    .disabled(!self.isQuiescent)
                } else {
                    Button(self.controller.output.isEmpty ? "Generate summary" : "Regenerate summary", systemImage: "sparkles") {
                        self.generate()
                    }
                    .fluidGlassAction(prominent: true)
                    .disabled(
                        (!self.usesOnDevice && self.route == nil) || self.needsCustomPrompt
                            || self.session?.transcriptSegments.isEmpty != false || !self.isQuiescent
                    )
                }
                if self.usesOnDevice, self.controller.installed {
                    Menu {
                        Button("Delete model", systemImage: "trash", role: .destructive) {
                            self.confirmDeletion = true
                        }
                        .disabled(self.controller.busy || self.controller.checking || !self.isQuiescent)
                    } label: { Image(systemName: "ellipsis") }
                        .menuIndicator(.hidden)
                        .fluidGlassAction(circular: true)
                        .accessibilityLabel("Summary model actions")
                        .disabled(self.controller.busy)
                }
            }
        }
    }

    private func generate() {
        guard let session else { return }
        if self.usesOnDevice {
            self.controller.summarizeOnDevice(
                session: session,
                kind: self.kind,
                customPrompt: self.preferences.customPrompt,
                thinking: self.preferences.thinksFirst,
                asr: AppServices.shared.asr
            )
            return
        }
        self.resolveRoute()
        if let route {
            self.controller.summarize(
                session: session,
                kind: self.kind,
                route: route,
                customPrompt: self.preferences.customPrompt
            )
        }
    }

    private var summaryDocument: some View {
        VStack(alignment: .leading, spacing: self.theme.metrics.spacing.md) {
            HStack(alignment: .top) {
                VStack(alignment: .leading, spacing: 4) {
                    Text(self.kind.title).font(.headline).accessibilityAddTraits(.isHeader)
                    Text("Generated with \(self.controller.outputProvenance)")
                        .font(self.theme.typography.caption)
                        .foregroundStyle(self.theme.palette.secondaryText)
                }
                Spacer()
                Button("Copy", systemImage: "doc.on.doc") {
                    NSPasteboard.general.clearContents()
                    NSPasteboard.general.setString(self.controller.output, forType: .string)
                }
                .labelStyle(.iconOnly).fluidGlassAction(circular: true)
                .help("Copy summary")
            }
            CommandMarkdownContent(text: self.controller.output)
            Text(self.controller.outputNotice)
                .font(self.theme.typography.caption)
                .foregroundStyle(self.theme.palette.secondaryText)
                .fixedSize(horizontal: false, vertical: true)
        }
        .padding(self.theme.metrics.spacing.lg)
        .frame(maxWidth: .infinity, alignment: .leading)
        .overlay(RoundedRectangle(cornerRadius: 12).strokeBorder(self.theme.palette.primaryText.opacity(0.1)))
    }

    private func selectModel(_ option: CommandModelOption) {
        guard option.providerID != MeetingSummaryOnDevice.providerID else {
            self.selectProvider(option.providerID)
            return
        }
        var selection = self.preferences.selection
        selection.providerID = option.providerID
        selection.modelsByProvider[ModelRepository.shared.providerKey(for: option.providerID)] = option.modelID
        self.preferences.selection = selection
    }

    private func selectProvider(_ providerID: String) {
        var selection = self.preferences.selection
        selection.providerID = providerID
        // The on-device choice has one model and no ModelRepository entry.
        guard providerID != MeetingSummaryOnDevice.providerID else {
            self.preferences.selection = selection
            return
        }
        let key = ModelRepository.shared.providerKey(for: providerID)
        if selection.modelsByProvider[key] == nil {
            let models = self.catalog.filter { ModelRepository.shared.providerKey(for: $0.providerID) == key }
            let preferred = self.settings.selectedModelByProvider[key]
            selection.modelsByProvider[key] = models.first(where: { $0.modelID == preferred })?.modelID ?? models.first?.modelID
        }
        self.preferences.selection = selection
    }

    private func reloadProviders() {
        self.catalog = self.settings.commandModeModelCatalog()
        self.onDeviceModel = self.controller.model
        self.catalogLoaded = true
        // First use starts from the AI Settings provider when it is verified; later choices stay independent.
        if self.providerID.isEmpty, let first = self.providers.first {
            let global = ModelRepository.shared.providerKey(for: self.settings.selectedProviderID)
            let preferred = self.providers.first { ModelRepository.shared.providerKey(for: $0.providerID) == global }
            self.selectProvider((preferred ?? first).providerID)
        } else if self.providerID.isEmpty, self.onDeviceModel != nil {
            // No cloud provider is set up, so the model on this Mac is the one choice.
            self.selectProvider(MeetingSummaryOnDevice.providerID)
        }
        self.resolveRoute()
    }

    private func resolveRoute() {
        guard !self.usesOnDevice else {
            self.route = nil
            self.readinessIssue = nil
            return
        }
        do {
            self.route = try MeetingSummaryRoute.resolve(self.preferences.selection, settings: self.settings)
            self.readinessIssue = nil
        } catch {
            self.route = nil
            self.readinessIssue = error.localizedDescription
        }
    }
}

/// Marks a text editor in the app's own window as somewhere dictation may write. Dictated text
/// otherwise goes to other apps, and inside the app only to the sidebar search field.
struct DictationTextTarget: NSViewRepresentable {
    final class Marker: NSView {
        override func hitTest(_: NSPoint) -> NSView? { nil }
    }

    func makeNSView(context _: Context) -> Marker { Marker() }
    func updateNSView(_: Marker, context _: Context) {}

    /// True when `editor` lies on a marker. SwiftUI hosts a background view and the editor it
    /// backs under a shared ancestor a few levels up, with the same frame.
    static func accepts(_ editor: NSTextView) -> Bool {
        guard editor.isEditable, !editor.isFieldEditor else { return false }
        let editorView: NSView = editor.enclosingScrollView ?? editor
        var ancestor = editorView.superview
        for _ in 0..<6 {
            guard let current = ancestor else { return false }
            let editorFrame = editorView.convert(editorView.bounds, to: current)
            var pending = current.subviews
            while let view = pending.popLast() {
                if view is Marker, view.convert(view.bounds, to: current).insetBy(dx: -2, dy: -2).contains(editorFrame) {
                    return true
                }
                pending.append(contentsOf: view.subviews)
            }
            ancestor = current.superview
        }
        return false
    }
}