@hasna/recordings 0.1.9 → 0.1.11

package/src/native/Recordings/Recordings/MenuBarPopover.swift

@@ -4,89 +4,81 @@ import KeyboardShortcuts
 struct MenuBarPopover: View {
     @ObservedObject var engine: RecordingEngine
     @ObservedObject var shortcuts: VoiceShortcuts
+    @ObservedObject var projectStore: ProjectStore
+    @State private var copiedIndex: Int?
+    @State private var filterProjectId: String?
+
+    private var filteredTranscriptions: [TranscriptionResult] {
+        guard let filter = filterProjectId else {
+            return engine.recentTranscriptions
+        }
+        if filter == "__none__" {
+            return engine.recentTranscriptions.filter { $0.projectId == nil }
+        }
+        return engine.recentTranscriptions.filter { $0.projectId == filter }
+    }
 
     var body: some View {
         VStack(spacing: 0) {
-            header.padding(.horizontal, 16).padding(.top, 12).padding(.bottom, 8)
-            Divider()
-            modeSelector.padding(.horizontal, 16).padding(.vertical, 10)
-            shortcutRow.padding(.horizontal, 16).padding(.bottom, 8)
+            header
+                .padding(.horizontal, 16).padding(.top, 12).padding(.bottom, 8)
             Divider()
-            recordingArea.padding(.horizontal, 16).padding(.vertical, 12)
+            recordingArea
+                .padding(.horizontal, 16).padding(.vertical, 12)
             Divider()
-            recentList.frame(maxHeight: 180)
+            if !engine.recentTranscriptions.isEmpty {
+                filterBar
+                    .padding(.horizontal, 16).padding(.vertical, 6)
+                Divider()
+            }
+            recentList
+                .frame(maxHeight: 200)
             Divider()
-            footer.padding(.horizontal, 16).padding(.vertical, 8)
+            footerMenu
         }
     }
 
     // MARK: - Header
 
     private var header: some View {
-        HStack {
-            Image(systemName: "mic.fill").font(.title3).foregroundStyle(.tint)
-            Text("Recordings").font(.headline)
-            Spacer()
-            Toggle(isOn: $engine.isWhisperMode) {
-                Label("Whisper", systemImage: "speaker.wave.1.fill").font(.caption)
-            }
-            .toggleStyle(.button).buttonStyle(.bordered).controlSize(.small)
-        }
-    }
-
-    // MARK: - Mode Selector
-
-    private var modeSelector: some View {
-        HStack(spacing: 8) {
-            modeBtn(.pushToTalk)
-            modeBtn(.dictation)
-            modeBtn(.command)
-        }
-    }
-
-    @ViewBuilder
-    private func modeBtn(_ m: RecordingMode) -> some View {
-        if engine.mode == m {
-            Button { engine.mode = m } label: {
-                Label(m.rawValue, systemImage: m.icon).font(.caption)
-                    .foregroundStyle(.white).frame(maxWidth: .infinity)
-            }.buttonStyle(.borderedProminent).controlSize(.small)
-        } else {
-            Button { engine.mode = m } label: {
-                Label(m.rawValue, systemImage: m.icon).font(.caption)
-                    .frame(maxWidth: .infinity)
-            }.buttonStyle(.bordered).controlSize(.small)
-        }
-    }
-
-    // MARK: - Shortcut Row
-
-    private var shortcutRow: some View {
-        VStack(spacing: 6) {
-            // fn key toggle
+        VStack(alignment: .leading, spacing: 4) {
             HStack {
-                Toggle(isOn: $engine.useFnKey) {
-                    HStack(spacing: 4) {
-                        Text("fn").font(.system(.caption, design: .monospaced)).bold()
-                        Text("Globe key").font(.caption).foregroundStyle(.secondary)
-                    }
+                Image(systemName: "mic.fill")
+                    .foregroundStyle(.tint)
+                Text("Hasna Recordings")
+                Spacer()
+                if let shortcut = KeyboardShortcuts.getShortcut(for: .toggleRecording) {
+                    Text(shortcut.description)
+                        .foregroundStyle(.secondary)
                 }
-                .toggleStyle(.switch).controlSize(.small)
             }
-
-            // Custom shortcut
-            HStack(spacing: 8) {
-                Text("Custom").font(.caption).foregroundStyle(.secondary)
-                Spacer()
-                let current = KeyboardShortcuts.getShortcut(for: .toggleRecording)
-                Text(current?.description ?? "None")
-                    .font(.system(.caption, design: .monospaced))
-                    .padding(.horizontal, 8).padding(.vertical, 3)
-                    .background(.quaternary, in: RoundedRectangle(cornerRadius: 5))
-
-                SettingsLink {
-                    Text("Set").font(.caption2)
-                }.buttonStyle(.bordered).controlSize(.mini)
+            if !projectStore.settings.projects.isEmpty {
+                HStack(spacing: 4) {
+                    Image(systemName: "folder.fill")
+                        .foregroundColor(projectStore.activeProject != nil ? .accentColor : .secondary)
+                    Menu {
+                        Button("None") { projectStore.setActive(nil) }
+                        Divider()
+                        ForEach(projectStore.settings.projects) { project in
+                            Button {
+                                projectStore.setActive(project.id)
+                            } label: {
+                                HStack {
+                                    Text(project.name)
+                                    if project.id == projectStore.settings.activeProjectId {
+                                        Image(systemName: "checkmark")
+                                    }
+                                }
+                            }
+                        }
+                    } label: {
+                        Text(projectStore.activeProject?.name ?? "No project")
+                            .foregroundStyle(projectStore.activeProject == nil ? .secondary : .primary)
+                    }
+                    .menuStyle(.borderlessButton)
+                    .fixedSize()
+                    Spacer()
+                }
             }
         }
     }
@@ -94,41 +86,94 @@ struct MenuBarPopover: View {
     // MARK: - Recording Area
 
     private var recordingArea: some View {
-        VStack(spacing: 8) {
+        Group {
             if engine.isRecording {
-                HStack(spacing: 12) {
-                    Circle().fill(.red).frame(width: 10, height: 10)
-                    Text(fmt(engine.recordingDuration))
-                        .font(.system(.title2, design: .monospaced))
-                    Spacer()
-                    Button("Stop") { engine.stopAndTranscribe() }
-                        .buttonStyle(.borderedProminent).tint(.red).controlSize(.small)
+                VStack(spacing: 6) {
+                    HStack {
+                        Circle().fill(.red).frame(width: 8, height: 8)
+                        Text(fmt(engine.recordingDuration))
+                            .monospacedDigit()
+                        Spacer()
+                        Button("Stop") { engine.stopAndTranscribe() }
+                            .controlSize(.small)
+                    }
+                    if let project = projectStore.activeProject {
+                        HStack(spacing: 4) {
+                            Image(systemName: "folder.fill").foregroundStyle(.tint)
+                            Text(project.name).foregroundStyle(.secondary)
+                            Spacer()
+                        }
+                    }
                 }
-                .padding(12).glassEffect(.regular.tint(.red))
+                .padding(10)
+                .glassEffect(.regular)
             } else if engine.isTranscribing {
-                HStack(spacing: 8) {
-                    ProgressView().controlSize(.small)
-                    Text("Transcribing...").font(.subheadline).foregroundStyle(.secondary)
+                VStack(spacing: 6) {
+                    HStack(spacing: 8) {
+                        ProgressView().controlSize(.small)
+                        Text("Transcribing...")
+                            .foregroundStyle(.secondary)
+                        Spacer()
+                    }
+                    if let project = projectStore.activeProject {
+                        HStack(spacing: 4) {
+                            Image(systemName: "folder.fill").foregroundStyle(.tint)
+                            Text(project.name).foregroundStyle(.secondary)
+                            Spacer()
+                        }
+                    }
                 }
-                .frame(maxWidth: .infinity).padding(12).glassEffect(.regular)
+                .frame(maxWidth: .infinity)
+                .padding(10)
+                .glassEffect(.regular)
             } else {
-                VStack(spacing: 10) {
+                VStack(spacing: 6) {
                     Button { engine.startRecording() } label: {
-                        Label("Record", systemImage: "mic.circle.fill").font(.title3)
-                    }.buttonStyle(.borderedProminent).controlSize(.large)
+                        Label("Record", systemImage: "mic.circle.fill")
+                    }
+                    .controlSize(.regular)
 
-                    Text(engine.mode.hint)
-                        .font(.callout).foregroundStyle(.primary.opacity(0.7))
-                        .multilineTextAlignment(.center)
-                        .fixedSize(horizontal: false, vertical: true)
+                    if let shortcut = KeyboardShortcuts.getShortcut(for: .toggleRecording) {
+                        Text("or hold \(shortcut.description)")
+                            .foregroundStyle(.tertiary)
+                    }
                 }
-                .frame(maxWidth: .infinity).padding(14).glassEffect(.clear)
+                .frame(maxWidth: .infinity)
+                .padding(10)
+                .glassEffect(.regular)
             }
+        }
+    }
 
-            Text(engine.statusMessage)
-                .font(.caption2).foregroundStyle(.secondary)
-                .lineLimit(2).truncationMode(.tail)
-                .frame(maxWidth: .infinity, alignment: .leading)
+    // MARK: - Filter Bar
+
+    private var filterBar: some View {
+        ScrollView(.horizontal, showsIndicators: false) {
+            HStack(spacing: 6) {
+                FilterChip(label: "All", isActive: filterProjectId == nil) {
+                    filterProjectId = nil
+                }
+                ForEach(projectStore.settings.projects) { project in
+                    let count = engine.recentTranscriptions.filter { $0.projectId == project.id }.count
+                    if count > 0 {
+                        FilterChip(
+                            label: "\(project.name) (\(count))",
+                            isActive: filterProjectId == project.id
+                        ) {
+                            filterProjectId = filterProjectId == project.id ? nil : project.id
+                        }
+                    }
+                }
+                let noProjectCount = engine.recentTranscriptions.filter { $0.projectId == nil }.count
+                if noProjectCount > 0 {
+                    FilterChip(
+                        label: "No project (\(noProjectCount))",
+                        isActive: filterProjectId == "__none__"
+                    ) {
+                        filterProjectId = filterProjectId == "__none__" ? nil : "__none__"
+                    }
+                }
+            }
         }
     }
 
@@ -136,18 +181,30 @@ struct MenuBarPopover: View {
 
     private var recentList: some View {
         Group {
-            if engine.recentTranscriptions.isEmpty {
-                VStack { Spacer()
-                    Text("No recent transcriptions").font(.caption).foregroundStyle(.quaternary)
-                    Spacer()
-                }.frame(maxWidth: .infinity)
+            if filteredTranscriptions.isEmpty {
+                Spacer()
             } else {
                 ScrollView {
-                    LazyVStack(alignment: .leading, spacing: 4) {
-                        ForEach(engine.recentTranscriptions.indices, id: \.self) { i in
-                            TranscriptionRow(item: engine.recentTranscriptions[i])
+                    LazyVStack(alignment: .leading, spacing: 2) {
+                        ForEach(filteredTranscriptions.indices, id: \.self) { i in
+                            let item = filteredTranscriptions[i]
+                            TranscriptionRow(
+                                item: item,
+                                showProject: filterProjectId == nil,
+                                isCopied: copiedIndex == i
+                            ) {
+                                NSPasteboard.general.clearContents()
+                                NSPasteboard.general.setString(item.displayText, forType: .string)
+                                withAnimation(.easeInOut(duration: 0.15)) {
+                                    copiedIndex = i
+                                }
+                                DispatchQueue.main.asyncAfter(deadline: .now() + 1.2) {
+                                    withAnimation { if copiedIndex == i { copiedIndex = nil } }
+                                }
+                            }
                         }
-                    }.padding(.horizontal, 16).padding(.vertical, 6)
+                    }
+                    .padding(.horizontal, 16).padding(.vertical, 6)
                 }
             }
         }
@@ -155,12 +212,33 @@ struct MenuBarPopover: View {
 
     // MARK: - Footer
 
-    private var footer: some View {
-        HStack {
-            SettingsLink { Image(systemName: "gear") }.buttonStyle(.borderless)
-            Spacer()
-            Button("Quit") { NSApplication.shared.terminate(nil) }
-                .buttonStyle(.borderless).foregroundStyle(.secondary)
+    private var footerMenu: some View {
+        VStack(spacing: 0) {
+            SettingsLink {
+                HStack {
+                    Text("Settings...")
+                    Spacer()
+                    Text("⌘,").foregroundStyle(.tertiary)
+                }
+                .contentShape(Rectangle())
+                .padding(.horizontal, 16).padding(.vertical, 6)
+            }
+            .buttonStyle(.plain)
+
+            Divider()
+
+            Button {
+                NSApplication.shared.terminate(nil)
+            } label: {
+                HStack {
+                    Text("Quit Hasna Recordings")
+                    Spacer()
+                    Text("⌘Q").foregroundStyle(.tertiary)
+                }
+                .contentShape(Rectangle())
+                .padding(.horizontal, 16).padding(.vertical, 6)
+            }
+            .buttonStyle(.plain)
         }
     }
 
@@ -169,20 +247,71 @@ struct MenuBarPopover: View {
     }
 }
 
+// MARK: - Filter Chip
+
+struct FilterChip: View {
+    let label: String
+    let isActive: Bool
+    let action: () -> Void
+
+    var body: some View {
+        Button(action: action) {
+            Text(label)
+                .padding(.horizontal, 8)
+                .padding(.vertical, 3)
+                .background(isActive ? Color.accentColor.opacity(0.15) : Color.clear)
+                .clipShape(RoundedRectangle(cornerRadius: 6))
+        }
+        .buttonStyle(.plain)
+        .foregroundStyle(isActive ? .primary : .secondary)
+    }
+}
+
+// MARK: - Transcription Row
+
 struct TranscriptionRow: View {
     let item: TranscriptionResult
+    let showProject: Bool
+    let isCopied: Bool
+    let onCopy: () -> Void
+
     var body: some View {
-        HStack(alignment: .top, spacing: 8) {
-            Text(item.displayText).font(.caption).lineLimit(2)
-                .frame(maxWidth: .infinity, alignment: .leading)
-            Text({ let s = Date().timeIntervalSince(item.timestamp)
-                return s < 60 ? "now" : s < 3600 ? "\(Int(s/60))m" : "\(Int(s/3600))h"
-            }()).font(.caption2).foregroundStyle(.tertiary)
+        VStack(alignment: .leading, spacing: 2) {
+            HStack(alignment: .top, spacing: 8) {
+                Text(item.displayText)
+                    .lineLimit(2)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+
+                if isCopied {
+                    Image(systemName: "checkmark")
+                        .foregroundStyle(.green)
+                        .transition(.scale.combined(with: .opacity))
+                } else {
+                    Text(relativeTime(item.timestamp))
+                        .foregroundStyle(.tertiary)
+                }
+            }
+            if showProject, let name = item.projectName {
+                HStack(spacing: 3) {
+                    Image(systemName: "folder")
+                    Text(name)
+                }
+                .foregroundStyle(.tertiary)
+            }
         }
-        .padding(.vertical, 4).contentShape(Rectangle())
-        .onTapGesture {
-            NSPasteboard.general.clearContents()
-            NSPasteboard.general.setString(item.displayText, forType: .string)
+        .padding(.vertical, 4)
+        .padding(.horizontal, 6)
+        .contentShape(Rectangle())
+        .onTapGesture { onCopy() }
+        .onHover { hovering in
+            if hovering { NSCursor.pointingHand.push() } else { NSCursor.pop() }
         }
     }
+
+    private func relativeTime(_ date: Date) -> String {
+        let s = Date().timeIntervalSince(date)
+        if s < 60 { return "now" }
+        if s < 3600 { return "\(Int(s / 60))m" }
+        return "\(Int(s / 3600))h"
+    }
 }

package/src/native/Recordings/Recordings/ProjectStore.swift

@@ -0,0 +1,126 @@
+import Foundation
+
+struct RecProject: Codable, Identifiable, Sendable {
+    let id: String
+    var name: String
+    var path: String?
+    var systemPrompt: String?
+    var appBundleIds: [String]?
+
+    init(name: String, path: String? = nil, systemPrompt: String? = nil, appBundleIds: [String]? = nil) {
+        self.id = UUID().uuidString
+        self.name = name
+        self.path = path
+        self.systemPrompt = systemPrompt
+        self.appBundleIds = appBundleIds
+    }
+}
+
+struct ProjectSettings: Codable, Sendable {
+    var globalSystemPrompt: String
+    var projects: [RecProject]
+    var activeProjectId: String?
+
+    init() {
+        globalSystemPrompt = ""
+        projects = []
+        activeProjectId = nil
+    }
+}
+
+@MainActor
+final class ProjectStore: ObservableObject {
+    @Published var settings = ProjectSettings()
+
+    private let filePath: String
+
+    var activeProject: RecProject? {
+        settings.projects.first { $0.id == settings.activeProjectId }
+    }
+
+    var effectiveSystemPrompt: String {
+        let global = settings.globalSystemPrompt.trimmingCharacters(in: .whitespacesAndNewlines)
+        let project = activeProject?.systemPrompt?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        if global.isEmpty && project.isEmpty { return "" }
+        if global.isEmpty { return project }
+        if project.isEmpty { return global }
+        return "\(global)\n\n\(project)"
+    }
+
+    init() {
+        let home = FileManager.default.homeDirectoryForCurrentUser.path
+        filePath = "\(home)/.hasna/recordings/projects.json"
+        load()
+    }
+
+    func load() {
+        guard FileManager.default.fileExists(atPath: filePath),
+              let data = FileManager.default.contents(atPath: filePath) else { return }
+        do {
+            settings = try JSONDecoder().decode(ProjectSettings.self, from: data)
+        } catch {
+            fputs("[ProjectStore] Failed to load: \(error)\n", stderr)
+        }
+    }
+
+    func save() {
+        do {
+            let data = try JSONEncoder().encode(settings)
+            let dir = (filePath as NSString).deletingLastPathComponent
+            try FileManager.default.createDirectory(atPath: dir, withIntermediateDirectories: true)
+            try data.write(to: URL(fileURLWithPath: filePath))
+        } catch {
+            fputs("[ProjectStore] Failed to save: \(error)\n", stderr)
+        }
+    }
+
+    func addProject(name: String, path: String? = nil, systemPrompt: String? = nil) {
+        let project = RecProject(name: name, path: path, systemPrompt: systemPrompt)
+        settings.projects.append(project)
+        save()
+    }
+
+    func updateProject(_ project: RecProject) {
+        guard let idx = settings.projects.firstIndex(where: { $0.id == project.id }) else { return }
+        settings.projects[idx] = project
+        save()
+    }
+
+    func removeProject(id: String) {
+        settings.projects.removeAll { $0.id == id }
+        if settings.activeProjectId == id { settings.activeProjectId = nil }
+        save()
+    }
+
+    func setActive(_ id: String?) {
+        settings.activeProjectId = id
+        save()
+    }
+
+    // MARK: - Auto-detection
+
+    nonisolated static func matchProject(windowTitle: String?, bundleId: String?, projects: [RecProject]) -> RecProject? {
+        if let bundleId {
+            if let match = projects.first(where: { $0.appBundleIds?.contains(bundleId) == true }) {
+                return match
+            }
+        }
+
+        if let title = windowTitle {
+            let lower = title.lowercased()
+            for project in projects {
+                let name = project.name.lowercased()
+                if lower.contains(name) { return project }
+                let slug = name.replacingOccurrences(of: " ", with: "-")
+                if lower.contains(slug) { return project }
+                if let path = project.path {
+                    let dirName = (path as NSString).lastPathComponent.lowercased()
+                    if lower.contains(dirName) { return project }
+                }
+            }
+        }
+
+        return nil
+    }
+
+}