@hasna/recordings 0.1.9 → 0.1.11

package/src/native/Recordings/Recordings/RecordingEngine.swift

@@ -4,7 +4,7 @@ import KeyboardShortcuts
 // MARK: - Custom shortcut (not fn — fn is handled by FnKeyMonitor)
 
 extension KeyboardShortcuts.Name {
-    static let toggleRecording = Self("toggleRecording")
+    static let toggleRecording = Self("toggleRecording", default: .init(.f5))
 }
 
 // MARK: - Recording Mode
@@ -24,9 +24,9 @@ enum RecordingMode: String, CaseIterable, Identifiable, Sendable {
     }
     var hint: String {
         switch self {
-        case .pushToTalk: return "Hold fn to record, release to stop & paste"
-        case .dictation: return "Hold fn to dictate, release to stop & paste"
-        case .command: return "Select text, hold fn, speak to rewrite"
+        case .pushToTalk: return "Hold F5 or your chosen shortcut to record, then release to paste"
+        case .dictation: return "Hold F5 or your chosen shortcut to dictate, then release to paste"
+        case .command: return "Select text, then hold F5 or your chosen shortcut and release to rewrite"
         }
     }
 }
@@ -37,16 +37,24 @@ struct TranscriptionResult: Sendable {
     let rawText: String
     let processedText: String?
     let timestamp: Date
+    let projectId: String?
+    let projectName: String?
     var displayText: String { processedText ?? rawText }
 }
 
+enum RecordingTrigger {
+    case manual
+    case fnKey
+    case keyboardShortcut
+}
+
 // MARK: - Recording Engine
 
 @MainActor
 final class RecordingEngine: ObservableObject {
     @Published var isRecording = false
     @Published var mode: RecordingMode = .pushToTalk
-    @Published var useFnKey: Bool = true {
+    @Published var useFnKey: Bool = false {
         didSet {
             UserDefaults.standard.set(useFnKey, forKey: "useFnKey")
             updateFnMonitor()
@@ -63,7 +71,12 @@ final class RecordingEngine: ObservableObject {
     private var stdinPipe: Pipe?
     private var currentAudioPath: String?
     private var recordingTimer: Timer?
+    private var activeTrigger: RecordingTrigger?
+    private var keyboardShortcutIsDown = false
+    private var targetAppBundleIdentifier: String?
+    private var targetAppPid: pid_t?
     private let maxDuration = 300
+    var projectStore: ProjectStore?
 
     // fn key monitor (CGEventTap-based, swallows fn to prevent emoji picker)
     private let fnMonitor = FnKeyMonitor()
@@ -75,27 +88,40 @@ final class RecordingEngine: ObservableObject {
         try? FileManager.default.createDirectory(atPath: audioDir, withIntermediateDirectories: true)
 
         // Load preferences
-        useFnKey = UserDefaults.standard.object(forKey: "useFnKey") as? Bool ?? true
+        useFnKey = UserDefaults.standard.object(forKey: "useFnKey") as? Bool ?? false
+        if KeyboardShortcuts.getShortcut(for: .toggleRecording) == nil {
+            KeyboardShortcuts.setShortcut(.init(.f5), for: .toggleRecording)
+        }
 
         // Set up fn key monitor — hold fn to record, release to stop (like WisprFlow)
         fnMonitor.onFnKeyDown = { [weak self] in
             Task { @MainActor [weak self] in
                 guard let self, self.useFnKey, !self.isRecording else { return }
-                self.startRecording()
+                self.startRecording(trigger: .fnKey)
             }
         }
         fnMonitor.onFnKeyUp = { [weak self] in
             Task { @MainActor [weak self] in
-                guard let self, self.useFnKey, self.isRecording else { return }
+                guard let self, self.useFnKey, self.isRecording, self.activeTrigger == .fnKey else { return }
                 self.stopAndTranscribe()
             }
         }
         updateFnMonitor()
 
-        // Set up custom shortcut (toggle mode — press to start, press to stop)
+        KeyboardShortcuts.onKeyDown(for: .toggleRecording) { [weak self] in
+            Task { @MainActor [weak self] in
+                guard let self, !self.keyboardShortcutIsDown else { return }
+                self.keyboardShortcutIsDown = true
+                guard !self.isRecording else { return }
+                self.startRecording(trigger: .keyboardShortcut)
+            }
+        }
         KeyboardShortcuts.onKeyUp(for: .toggleRecording) { [weak self] in
             Task { @MainActor [weak self] in
-                self?.toggleRecording()
+                guard let self, self.keyboardShortcutIsDown else { return }
+                self.keyboardShortcutIsDown = false
+                guard self.isRecording, self.activeTrigger == .keyboardShortcut else { return }
+                self.stopAndTranscribe()
             }
         }
 
@@ -106,7 +132,7 @@ final class RecordingEngine: ObservableObject {
         if useFnKey {
             let ok = fnMonitor.start()
             if !ok {
-                statusMessage = "fn needs Accessibility permission (System Settings > Privacy & Security > Accessibility)"
+                statusMessage = "fn needs Input Monitoring / Accessibility permission, and Globe must be set to Do Nothing"
             }
         } else {
             fnMonitor.stop()
@@ -115,32 +141,36 @@ final class RecordingEngine: ObservableObject {
 
     func updateStatus() {
         if isRecording || isTranscribing { return }
-
-        var parts: [String] = []
-        if useFnKey {
-            parts.append("fn (hold)")
-        }
-        if let shortcut = KeyboardShortcuts.getShortcut(for: .toggleRecording) {
-            parts.append(shortcut.description)
-        }
-
-        if parts.isEmpty {
-            statusMessage = "No shortcut set — enable fn or set a custom shortcut"
-        } else {
-            statusMessage = "Ready — press \(parts.joined(separator: " or ")) to record"
-        }
+        statusMessage = "Ready"
     }
 
     // MARK: - Toggle
 
     func toggleRecording() {
-        if isRecording { stopAndTranscribe() } else { startRecording() }
+        if isRecording { stopAndTranscribe() } else { startRecording(trigger: .manual) }
     }
 
     // MARK: - Start Recording
 
-    func startRecording() {
+    func startRecording(trigger: RecordingTrigger = .manual) {
         guard !isRecording else { return }
+        activeTrigger = trigger
+        keyboardShortcutIsDown = trigger == .keyboardShortcut
+
+        let myPID = ProcessInfo.processInfo.processIdentifier
+        let frontmostApp = NSWorkspace.shared.frontmostApplication
+        let isOwnApp = frontmostApp?.processIdentifier == myPID
+        targetAppBundleIdentifier = isOwnApp ? nil : frontmostApp?.bundleIdentifier
+        targetAppPid = isOwnApp ? nil : frontmostApp?.processIdentifier
+
+        if let store = projectStore {
+            let windowTitle = Self.focusedWindowTitle(pid: frontmostApp?.processIdentifier)
+            let projects = store.settings.projects
+            let detected = ProjectStore.matchProject(windowTitle: windowTitle, bundleId: targetAppBundleIdentifier, projects: projects)
+            if let detected {
+                store.setActive(detected.id)
+            }
+        }
 
         let ts = DateFormatter()
         ts.dateFormat = "yyyyMMdd'T'HHmmss"
@@ -149,11 +179,12 @@ final class RecordingEngine: ObservableObject {
 
         let proc = Process()
         let stdin = Pipe()
+        let stderrPipe = Pipe()
         proc.executableURL = URL(fileURLWithPath: "/bin/bash")
         proc.arguments = ["-c", """
             export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"
             if command -v ffmpeg &>/dev/null; then
-                ffmpeg -f avfoundation -i ":0" -ar 16000 -ac 1 -t \(maxDuration) "\(path)" -y 2>/dev/null
+                ffmpeg -f avfoundation -i ":0" -ar 16000 -ac 1 -t \(maxDuration) "\(path)" -y
             elif command -v rec &>/dev/null; then
                 rec -r 16000 -c 1 -b 16 "\(path)" trim 0 \(maxDuration)
             else
@@ -162,7 +193,7 @@ final class RecordingEngine: ObservableObject {
         """]
         proc.standardInput = stdin
         proc.standardOutput = FileHandle.nullDevice
-        proc.standardError = FileHandle.nullDevice
+        proc.standardError = stderrPipe
 
         do {
             try proc.run()
@@ -170,7 +201,11 @@ final class RecordingEngine: ObservableObject {
             stdinPipe = stdin
             isRecording = true
             recordingDuration = 0
-            statusMessage = mode == .command ? "Speak your instruction..." : "Recording — press fn to stop"
+            statusMessage = switch (mode, trigger) {
+            case (.command, _): "Speak your instruction..."
+            case (_, .manual): "Recording — click Stop when finished"
+            case (_, .fnKey), (_, .keyboardShortcut): "Recording — release to stop"
+            }
 
             recordingTimer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in
                 Task { @MainActor [weak self] in
@@ -178,6 +213,9 @@ final class RecordingEngine: ObservableObject {
                 }
             }
         } catch {
+            activeTrigger = nil
+            keyboardShortcutIsDown = false
+            targetAppBundleIdentifier = nil
             statusMessage = "Failed: \(error.localizedDescription)"
         }
     }
@@ -204,6 +242,14 @@ final class RecordingEngine: ObservableObject {
         currentAudioPath = nil
         recordProcess = nil
         stdinPipe = nil
+        let targetAppBundleIdentifier = targetAppBundleIdentifier
+        let systemPrompt = projectStore?.effectiveSystemPrompt ?? ""
+        let activeProjectId = projectStore?.settings.activeProjectId
+        let activeProjectName = projectStore?.activeProject?.name
+        activeTrigger = nil
+        keyboardShortcutIsDown = false
+        self.targetAppBundleIdentifier = nil
+        self.targetAppPid = nil
         let homePath = home
 
         Task.detached {
@@ -212,6 +258,12 @@ final class RecordingEngine: ObservableObject {
             try? await Task.sleep(for: .milliseconds(300))
             if proc.isRunning { proc.interrupt() }
 
+            // Check if ffmpeg exited with an error (e.g. no mic permission)
+            if proc.terminationStatus != 0, proc.terminationStatus != 1 {
+                await MainActor.run { self.finish("Recording failed (mic access denied — check System Settings > Privacy & Security > Microphone)") }
+                return
+            }
+
             guard let audioPath else {
                 await MainActor.run { self.finish("No audio file") }
                 return
@@ -220,13 +272,21 @@ final class RecordingEngine: ObservableObject {
             let attrs = try? FileManager.default.attributesOfItem(atPath: audioPath)
             let size = (attrs?[.size] as? Int) ?? 0
             guard size >= 1000 else {
-                await MainActor.run { self.finish("Audio too short — speak longer") }
+                await MainActor.run { self.finish("No audio captured — check microphone permissions") }
                 return
             }
 
-            let output = CLIRunner.run(["transcribe", audioPath, "--json"], home: homePath)
-            let text = CLIRunner.parseJSON(output)
+            var cliArgs = ["transcribe", audioPath, "--json"]
+            if !systemPrompt.isEmpty {
+                cliArgs += ["--system-prompt", systemPrompt]
+            }
+            let output = CLIRunner.run(cliArgs, home: homePath)
+            if let error = CLIRunner.parseError(output) {
+                await MainActor.run { self.finish(error) }
+                return
+            }
 
+            let text = CLIRunner.parseJSON(output)
             guard let text, !text.isEmpty else {
                 await MainActor.run { self.finish("Empty transcription") }
                 return
@@ -237,12 +297,12 @@ final class RecordingEngine: ObservableObject {
                 if curMode == .command {
                     self.runCommandMode(instruction: text)
                 } else {
-                    self.pasteIntoFrontApp(text)
+                    self.pasteIntoFrontApp(text, targetAppBundleIdentifier: targetAppBundleIdentifier)
                     self.recentTranscriptions.insert(
-                        TranscriptionResult(rawText: text, processedText: nil, timestamp: Date()), at: 0
+                        TranscriptionResult(rawText: text, processedText: nil, timestamp: Date(), projectId: activeProjectId, projectName: activeProjectName), at: 0
                     )
                     if self.recentTranscriptions.count > 20 { self.recentTranscriptions.removeLast() }
-                    self.statusMessage = "Pasted: \(String(text.prefix(50)))"
+                    // statusMessage updated by pasteIntoFrontApp
                 }
             }
         }
@@ -250,7 +310,7 @@ final class RecordingEngine: ObservableObject {
 
     private func finish(_ msg: String) {
         isTranscribing = false
-        statusMessage = msg
+        updateStatus()
     }
 
     // MARK: - Command Mode
@@ -285,35 +345,53 @@ final class RecordingEngine: ObservableObject {
         }
     }
 
+    // MARK: - Window Title (Accessibility API)
+
+    private static func focusedWindowTitle(pid: pid_t?) -> String? {
+        guard let pid else { return nil }
+        let app = AXUIElementCreateApplication(pid)
+        var windowRef: CFTypeRef?
+        guard AXUIElementCopyAttributeValue(app, kAXFocusedWindowAttribute as CFString, &windowRef) == .success,
+              let window = windowRef else { return nil }
+        var titleRef: CFTypeRef?
+        guard AXUIElementCopyAttributeValue(window as! AXUIElement, kAXTitleAttribute as CFString, &titleRef) == .success,
+              let title = titleRef as? String else { return nil }
+        return title
+    }
+
     // MARK: - Paste
 
-    func pasteIntoFrontApp(_ text: String) {
+    func pasteIntoFrontApp(_ text: String, targetAppBundleIdentifier: String? = nil) {
         let pb = NSPasteboard.general
         pb.clearContents()
         pb.setString(text, forType: .string)
 
-        // Activate the last user app (not us)
         let myPID = ProcessInfo.processInfo.processIdentifier
-        if let target = NSWorkspace.shared.runningApplications.first(where: {
+        let runningApps = NSWorkspace.shared.runningApplications
+        let targetApp = runningApps.first(where: {
+            guard $0.processIdentifier != myPID, $0.activationPolicy == .regular else { return false }
+            guard let bundleIdentifier = targetAppBundleIdentifier else { return false }
+            return $0.bundleIdentifier == bundleIdentifier
+        }) ?? runningApps.first(where: {
             $0.activationPolicy == .regular && $0.processIdentifier != myPID
-        }) {
-            target.activate()
-        }
+        })
+
+        targetApp?.activate()
 
-        // Wait for activation, then Cmd+V
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
             self.postKey(0x09, flags: .maskCommand)
+            self.updateStatus()
         }
     }
 
     private func postKey(_ key: CGKeyCode, flags: CGEventFlags) {
         let src = CGEventSource(stateID: .hidSystemState)
-        let down = CGEvent(keyboardEventSource: src, virtualKey: key, keyDown: true)
-        down?.flags = flags
-        down?.post(tap: .cghidEventTap)
-        let up = CGEvent(keyboardEventSource: src, virtualKey: key, keyDown: false)
-        up?.flags = flags
-        up?.post(tap: .cghidEventTap)
+        guard let down = CGEvent(keyboardEventSource: src, virtualKey: key, keyDown: true),
+              let up = CGEvent(keyboardEventSource: src, virtualKey: key, keyDown: false) else { return }
+        down.flags = flags
+        up.flags = flags
+        down.post(tap: .cgSessionEventTap)
+        up.post(tap: .cgSessionEventTap)
     }
 }
 
@@ -324,19 +402,41 @@ enum CLIRunner: Sendable {
         let bin = "\(home)/.bun/bin/recordings"
         let escaped = args.map { "\"\($0)\"" }.joined(separator: " ")
         let proc = Process()
-        let pipe = Pipe()
+        let outPipe = Pipe()
+        let errPipe = Pipe()
         proc.executableURL = URL(fileURLWithPath: "/bin/bash")
         proc.arguments = ["-c", """
             export PATH="\(home)/.bun/bin:/opt/homebrew/bin:/usr/local/bin:$PATH"
             "\(bin)" \(escaped)
         """]
-        proc.standardOutput = pipe
-        proc.standardError = FileHandle.nullDevice
+        proc.standardOutput = outPipe
+        proc.standardError = errPipe
         do {
             try proc.run()
             proc.waitUntilExit()
-            return String(data: pipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
-        } catch { return "" }
+            let stdout = String(data: outPipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
+            let stderr = String(data: errPipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
+            if proc.terminationStatus != 0 {
+                let details = stderr.isEmpty ? stdout : stderr
+                return "ERROR: \(details.trimmingCharacters(in: .whitespacesAndNewlines))"
+            }
+            return stdout.isEmpty ? stderr : stdout
+        } catch {
+            return "ERROR: \(error.localizedDescription)"
+        }
+    }
+
+    static func parseError(_ output: String) -> String? {
+        let trimmed = output.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard trimmed.hasPrefix("ERROR:") else { return nil }
+        let message = trimmed.dropFirst("ERROR:".count).trimmingCharacters(in: .whitespacesAndNewlines)
+        if message.contains("OpenAI API key not configured") {
+            return "OpenAI API key not configured on this Mac"
+        }
+        if message.isEmpty {
+            return "Transcription failed"
+        }
+        return String(message.prefix(120))
     }
 
     static func parseJSON(_ output: String) -> String? {
@@ -350,6 +450,6 @@ enum CLIRunner: Sendable {
         }
         return output.components(separatedBy: "\n")
             .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
-            .first { !$0.isEmpty && !$0.hasPrefix("{") && !$0.contains("Transcribing") && !$0.hasPrefix("Saved") }
+            .first { !$0.isEmpty && !$0.hasPrefix("{") && !$0.contains("Transcribing") && !$0.hasPrefix("Saved") && !$0.hasPrefix("ERROR:") }
     }
 }

package/src/native/Recordings/Recordings/RecordingsApp.swift

@@ -1,3 +1,4 @@
+@preconcurrency import Cocoa
 import SwiftUI
 import KeyboardShortcuts
 
@@ -5,11 +6,19 @@ import KeyboardShortcuts
 struct RecordingsApp: App {
     @StateObject private var engine = RecordingEngine()
     @StateObject private var shortcuts = VoiceShortcuts()
+    @StateObject private var projectStore = ProjectStore()
+
+    init() {
+        AXIsProcessTrustedWithOptions(
+            [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
+        )
+    }
 
     var body: some Scene {
         MenuBarExtra {
-            MenuBarPopover(engine: engine, shortcuts: shortcuts)
-                .frame(width: 320, height: 440)
+            MenuBarPopover(engine: engine, shortcuts: shortcuts, projectStore: projectStore)
+                .frame(width: 320, height: 420)
+                .onAppear { engine.projectStore = projectStore }
         } label: {
             if engine.isRecording {
                 Image(systemName: "record.circle.fill")
@@ -22,9 +31,8 @@ struct RecordingsApp: App {
         }
         .menuBarExtraStyle(.window)
 
-        // Settings window — opened via SettingsLink
         Settings {
-            SettingsView(engine: engine, shortcuts: shortcuts)
+            SettingsView(engine: engine, shortcuts: shortcuts, projectStore: projectStore)
         }
     }
 }

package/src/native/Recordings/Recordings/SettingsView.swift

@@ -4,61 +4,101 @@ import KeyboardShortcuts
 struct SettingsView: View {
     @ObservedObject var engine: RecordingEngine
     @ObservedObject var shortcuts: VoiceShortcuts
-    @State private var newTrigger = ""
-    @State private var newContent = ""
+    @ObservedObject var projectStore: ProjectStore
 
     var body: some View {
         TabView {
             generalTab.tabItem { Label("General", systemImage: "gear") }
+            projectsTab.tabItem { Label("Projects", systemImage: "folder") }
             shortcutsTab.tabItem { Label("Voice Shortcuts", systemImage: "text.badge.star") }
         }
-        .frame(width: 480, height: 400)
+        .frame(width: 520, height: 440)
     }
 
+    // MARK: - General
+
     private var generalTab: some View {
         Form {
-            Section("Shortcut — fn Key") {
-                Toggle("Use fn (Globe) key", isOn: $engine.useFnKey)
-
-                if engine.useFnKey {
-                    Text("Hold fn to record, release to stop and paste.")
-                        .font(.caption).foregroundStyle(.secondary)
-                    HStack(spacing: 4) {
-                        Image(systemName: "exclamationmark.triangle.fill")
-                            .foregroundStyle(.orange)
-                        Text("Required: System Settings → Keyboard → set \"Press 🌐 key to: Do Nothing\"")
-                            .font(.caption)
-                    }
-                    Button("Open Keyboard Settings") {
-                        NSWorkspace.shared.open(URL(string: "x-apple.systempreferences:com.apple.Keyboard-Settings.extension")!)
-                    }.controlSize(.small)
-                }
-            }
-
-            Section("Shortcut — Custom Key") {
+            Section("Recording Shortcut") {
                 HStack {
-                    Text("Toggle Recording")
+                    Text("Shortcut")
                     Spacer()
                     KeyboardShortcuts.Recorder(for: .toggleRecording) { _ in
                         engine.updateStatus()
                     }
                 }
-                Text("Click the field and press any key combo (e.g. ⌥D, ⌃R, F5).")
-                    .font(.caption).foregroundStyle(.secondary)
+                Text("Hold to record, release to transcribe and paste.")
+                    .foregroundStyle(.secondary)
             }
 
-            Section("Recording") {
-                Picker("Mode", selection: $engine.mode) {
-                    ForEach(RecordingMode.allCases) { m in
-                        Label(m.rawValue, systemImage: m.icon).tag(m)
+            Section("System Prompt") {
+                TextEditor(text: $projectStore.settings.globalSystemPrompt)
+                    .frame(height: 80)
+                    .onChange(of: projectStore.settings.globalSystemPrompt) {
+                        projectStore.save()
                     }
-                }
-                Toggle("Whisper Mode", isOn: $engine.isWhisperMode)
+                Text("Applied to all transcription enhancements.")
+                    .foregroundStyle(.secondary)
             }
         }
         .formStyle(.grouped).padding()
     }
 
+    // MARK: - Projects
+
+    @State private var newProjectName = ""
+    @State private var editingProject: RecProject?
+
+    private var projectsTab: some View {
+        VStack(spacing: 0) {
+            HStack(spacing: 8) {
+                TextField("New project name", text: $newProjectName)
+                    .textFieldStyle(.roundedBorder)
+                Button("Add") {
+                    guard !newProjectName.isEmpty else { return }
+                    projectStore.addProject(name: newProjectName)
+                    newProjectName = ""
+                }
+                .disabled(newProjectName.isEmpty)
+            }
+            .padding()
+
+            Divider()
+
+            if projectStore.settings.projects.isEmpty {
+                Spacer()
+                VStack(spacing: 8) {
+                    Image(systemName: "folder").font(.largeTitle).foregroundStyle(.quaternary)
+                    Text("No projects yet").foregroundStyle(.secondary)
+                }
+                Spacer()
+            } else {
+                List {
+                    ForEach(projectStore.settings.projects) { project in
+                        ProjectRow(project: project) {
+                            editingProject = project
+                        }
+                    }
+                    .onDelete { indexSet in
+                        for i in indexSet {
+                            projectStore.removeProject(id: projectStore.settings.projects[i].id)
+                        }
+                    }
+                }
+            }
+        }
+        .sheet(item: $editingProject) { project in
+            ProjectEditView(project: project, store: projectStore) {
+                editingProject = nil
+            }
+        }
+    }
+
+    // MARK: - Voice Shortcuts
+
+    @State private var newTrigger = ""
+    @State private var newContent = ""
+
     private var shortcutsTab: some View {
         VStack(spacing: 0) {
             HStack(spacing: 8) {
@@ -68,9 +108,13 @@ struct SettingsView: View {
                     guard !newTrigger.isEmpty, !newContent.isEmpty else { return }
                     shortcuts.add(trigger: newTrigger, content: newContent)
                     newTrigger = ""; newContent = ""
-                }.buttonStyle(.borderedProminent).disabled(newTrigger.isEmpty || newContent.isEmpty)
-            }.padding()
+                }
+                .disabled(newTrigger.isEmpty || newContent.isEmpty)
+            }
+            .padding()
+
             Divider()
+
             if shortcuts.shortcuts.isEmpty {
                 Spacer()
                 VStack(spacing: 8) {
@@ -82,12 +126,79 @@ struct SettingsView: View {
                 List {
                     ForEach(shortcuts.shortcuts) { s in
                         VStack(alignment: .leading) {
-                            Text(s.trigger).font(.body.bold())
-                            Text(s.content).font(.caption).foregroundStyle(.secondary).lineLimit(2)
+                            Text(s.trigger).bold()
+                            Text(s.content).foregroundStyle(.secondary).lineLimit(2)
                         }
-                    }.onDelete(perform: shortcuts.remove)
+                    }
+                    .onDelete(perform: shortcuts.remove)
+                }
+            }
+        }
+    }
+}
+
+// MARK: - Project Row
+
+struct ProjectRow: View {
+    let project: RecProject
+    let onEdit: () -> Void
+
+    var body: some View {
+        HStack {
+            VStack(alignment: .leading, spacing: 2) {
+                Text(project.name)
+                if let path = project.path, !path.isEmpty {
+                    Text(path).foregroundStyle(.secondary).lineLimit(1)
+                }
+            }
+            Spacer()
+            Button("Edit") { onEdit() }
+                .controlSize(.small)
+        }
+    }
+}
+
+// MARK: - Project Edit
+
+struct ProjectEditView: View {
+    @State var project: RecProject
+    let store: ProjectStore
+    let onDismiss: () -> Void
+
+    var body: some View {
+        VStack(spacing: 0) {
+            Form {
+                Section("Project") {
+                    TextField("Name", text: $project.name)
+                    TextField("Path", text: Binding(
+                        get: { project.path ?? "" },
+                        set: { project.path = $0.isEmpty ? nil : $0 }
+                    ))
+                    .textFieldStyle(.roundedBorder)
+                }
+
+                Section("System Prompt") {
+                    TextEditor(text: Binding(
+                        get: { project.systemPrompt ?? "" },
+                        set: { project.systemPrompt = $0.isEmpty ? nil : $0 }
+                    ))
+                    .frame(height: 100)
+                    Text("Additional context for transcription enhancement in this project.")
+                        .foregroundStyle(.secondary)
+                }
+            }
+            .formStyle(.grouped)
+
+            HStack {
+                Spacer()
+                Button("Cancel") { onDismiss() }
+                Button("Save") {
+                    store.updateProject(project)
+                    onDismiss()
                 }
             }
+            .padding()
         }
+        .frame(width: 420, height: 340)
     }
 }