Cognee desktop: share-from-anywhere, quick capture, voice notes, git memory hook

integrations/desktop/desktop_backend/config.py

@@ -22,6 +22,11 @@
     ".txt",
     ".rst",
     ".org",
+    # voice notes and meeting recordings — cognee's loaders transcribe audio
+    ".mp3",
+    ".m4a",
+    ".wav",
+    ".aac",
     ".pdf",
     ".docx",
     ".pptx",

integrations/desktop/desktop_backend/server.py

@@ -55,6 +55,12 @@ class FeedbackRequest(BaseModel):
     rating: int  # 1-5; >=4 reinforces memory
 
 
+class CaptureRequest(BaseModel):
+    text: str
+    title: str = ""
+    source: str = ""  # e.g. "quick-capture", "git:repo-name", "share-sheet"
+
+
 class ForgetRequest(BaseModel):
     path: str  # an indexed file, or a whole watched root
 
@@ -476,6 +482,33 @@ def cache_put(key: tuple, value: dict) -> None:
             search_cache.pop(next(iter(search_cache)))
         search_cache[key] = (time.time(), value)
 
+    @app.post("/capture", status_code=202)
+    async def capture(request: CaptureRequest) -> dict:
+        """One thought (or commit, or shared selection) into memory.
+
+        The note lands in the capture folder and indexes like any document —
+        quick-capture hotkey, the share CLI, and the git hook all funnel here.
+        """
+        import re as _re
+        import time as _time
+
+        text = request.text.strip()
+        if not text:
+            return {"ok": False, "detail": "empty"}
+        title = request.title.strip() or text.splitlines()[0][:60]
+        slug = _re.sub(r"[^a-zA-Z0-9]+", "-", title.lower()).strip("-") or "note"
+        capture_dir = settings.data_dir / "capture"
+        capture_dir.mkdir(parents=True, exist_ok=True)
+        stamp = _time.strftime("%Y%m%d-%H%M%S")
+        path = capture_dir / f"{stamp}-{slug}.md"
+        header = f"# {title}\n\n"
+        if request.source:
+            header += f"- captured from: {request.source}\n"
+        header += f"- captured at: {_time.strftime('%Y-%m-%d %H:%M')}\n\n"
+        path.write_text(header + text + "\n")
+        indexer.start([str(capture_dir)])
+        return {"ok": True, "path": str(path)}
+
     @app.post("/feedback")
     async def feedback(request: FeedbackRequest) -> dict:
         if not settings.experiments:

integrations/desktop/macos/Sources/CogneeDesktop/AppDelegate.swift

@@ -1,4 +1,5 @@
 import AppKit
+import Carbon.HIToolbox
 import SwiftUI
 
 @MainActor
@@ -8,6 +9,8 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
     private var statusItem: NSStatusItem!
     private var panelController: SearchPanelController!
     private var hotKey: GlobalHotKey?
+    private var captureHotKey: GlobalHotKey?
+    private var capturePanelController: CapturePanelController?
     private var settingsWindow: NSWindow?
     private var inboxWindow: NSWindow?
     private var shareWindow: NSWindow?
@@ -27,6 +30,14 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
             self?.panelController.toggle()
         }
 
+        // ⌥⇧Space: quick capture — one line straight into memory.
+        capturePanelController = CapturePanelController()
+        captureHotKey = GlobalHotKey(
+            modifiers: UInt32(optionKey | shiftKey), id: 2
+        ) { [weak self] in
+            self?.capturePanelController?.toggle()
+        }
+
         notifier.onUnseenCount = { [weak self] unseen in
             self?.statusItem?.button?.toolTip =
                 unseen > 0 ? "Cognee — \(unseen) new learnings" : "Cognee"

integrations/desktop/macos/Sources/CogneeDesktop/BackendClient.swift

@@ -257,6 +257,10 @@ struct BackendClient {
         try await post("feedback", body: ["query": query, "answer": answer, "rating": rating])
     }
 
+    func capture(text: String, title: String = "", source: String = "") async throws {
+        try await post("capture", body: ["text": text, "title": title, "source": source])
+    }
+
     func health() async throws -> Health {
         try await get(baseURL.appendingPathComponent("health"))
     }

integrations/desktop/macos/Sources/CogneeDesktop/CapturePanel.swift

@@ -0,0 +1,190 @@
+import AppKit
+import SwiftUI
+
+/// ⌥⇧Space: one line into memory. Type the thought, hit ↩, keep working —
+/// the note lands in the capture folder and indexes like any document.
+@MainActor
+final class CaptureModel: ObservableObject {
+    @Published var text = "" {
+        didSet { scheduleWhisper() }
+    }
+    @Published var status: String?
+    /// Memory talking back while you type: closest known fact, or a conflict.
+    @Published var whisper: String?
+    @Published var whisperIsConflict = false
+    var onDone: (() -> Void)?
+    private var whisperTask: Task<Void, Never>?
+
+    /// Debounced /whisper lookup — memory reacts to the note, not keystrokes.
+    private func scheduleWhisper() {
+        whisperTask?.cancel()
+        let note = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard note.count >= 12 else {
+            whisper = nil
+            whisperIsConflict = false
+            return
+        }
+        whisperTask = Task { [weak self] in
+            try? await Task.sleep(nanoseconds: 500_000_000)
+            guard let self, !Task.isCancelled,
+                let response = try? await BackendClient().whisper(note),
+                !Task.isCancelled,
+                note == self.text.trimmingCharacters(in: .whitespacesAndNewlines)
+            else { return }
+            if let conflict = response.conflicts.first {
+                self.whisper = "conflicts with memory: \(conflict.a) vs \(conflict.b)"
+                self.whisperIsConflict = true
+            } else if let related = response.related.first {
+                self.whisper = "memory knows: \(related)"
+                self.whisperIsConflict = false
+            } else {
+                self.whisper = nil
+                self.whisperIsConflict = false
+            }
+        }
+    }
+
+    func submit() {
+        let note = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !note.isEmpty else {
+            onDone?()
+            return
+        }
+        status = "Remembering…"
+        Task { [weak self] in
+            do {
+                try await BackendClient().capture(text: note, source: "quick-capture")
+                self?.status = "Remembered ✓"
+            } catch {
+                self?.status = "Backend unreachable"
+            }
+            try? await Task.sleep(nanoseconds: 700_000_000)
+            self?.text = ""
+            self?.status = nil
+            self?.whisper = nil
+            self?.onDone?()
+        }
+    }
+}
+
+struct CaptureView: View {
+    @ObservedObject var model: CaptureModel
+    @FocusState private var focused: Bool
+
+    var body: some View {
+        VStack(spacing: 0) {
+            HStack(spacing: 10) {
+                Image(systemName: "brain")
+                    .font(.system(size: 15, weight: .medium))
+                    .foregroundStyle(Color.cognee)
+                TextField("Remember this…", text: $model.text)
+                    .textFieldStyle(.plain)
+                    .font(.system(size: 16))
+                    .focused($focused)
+                    .onSubmit { model.submit() }
+                if let status = model.status {
+                    Text(status).font(.system(size: 11)).foregroundStyle(.secondary)
+                }
+            }
+            .padding(.horizontal, 14)
+            .frame(height: 44)
+            if let whisper = model.whisper {
+                Divider().padding(.horizontal, 12).opacity(0.5)
+                HStack(spacing: 7) {
+                    Image(
+                        systemName: model.whisperIsConflict
+                            ? "exclamationmark.triangle.fill" : "sparkle"
+                    )
+                    .font(.system(size: 10))
+                    .foregroundStyle(
+                        model.whisperIsConflict ? AnyShapeStyle(.orange) : AnyShapeStyle(Color.cognee)
+                    )
+                    Text(whisper)
+                        .font(.system(size: 11))
+                        .foregroundStyle(.secondary)
+                        .lineLimit(2)
+                    Spacer(minLength: 0)
+                }
+                .padding(.horizontal, 14)
+                .padding(.vertical, 7)
+            }
+        }
+        .frame(width: 460)
+        .background(.regularMaterial, in: RoundedRectangle(cornerRadius: 12, style: .continuous))
+        .overlay(
+            RoundedRectangle(cornerRadius: 12, style: .continuous)
+                .strokeBorder(.white.opacity(0.18), lineWidth: 1)
+        )
+        .shadow(color: .black.opacity(0.3), radius: 20, y: 8)
+        .padding(24)
+        // fixed canvas with headroom for the whisper row — the panel window
+        // never resizes (content outside a fitted window clips to nothing)
+        .frame(width: 508, height: 140, alignment: .top)
+        .onAppear { focused = true }
+        .animation(.easeOut(duration: 0.14), value: model.whisper)
+    }
+}
+
+@MainActor
+final class CapturePanelController: NSObject, NSWindowDelegate {
+    private let model = CaptureModel()
+    private var panel: SearchPanel!
+    private var keyMonitor: Any?
+
+    override init() {
+        super.init()
+        panel = SearchPanel(
+            contentRect: NSRect(x: 0, y: 0, width: 508, height: 140),
+            styleMask: [.borderless, .nonactivatingPanel],
+            backing: .buffered,
+            defer: false
+        )
+        let hosting = NSHostingController(rootView: CaptureView(model: model))
+        hosting.sizingOptions = []
+        panel.contentViewController = hosting
+        panel.setContentSize(NSSize(width: 508, height: 140))
+        panel.isOpaque = false
+        panel.backgroundColor = .clear
+        panel.hasShadow = false
+        panel.level = .floating
+        panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .transient]
+        panel.delegate = self
+        model.onDone = { [weak self] in self?.hide() }
+    }
+
+    func toggle() {
+        panel.isVisible ? hide() : show()
+    }
+
+    private func show() {
+        let screen =
+            NSScreen.screens.first { NSMouseInRect(NSEvent.mouseLocation, $0.frame, false) }
+            ?? NSScreen.main
+        if let frame = screen?.visibleFrame {
+            panel.setFrameOrigin(
+                NSPoint(
+                    x: frame.midX - panel.frame.width / 2,
+                    y: frame.minY + frame.height * 0.78
+                ))
+        }
+        panel.makeKeyAndOrderFront(nil)
+        keyMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { [weak self] event in
+            guard let self, self.panel.isKeyWindow else { return event }
+            if event.keyCode == 53 {  // esc
+                self.hide()
+                return nil
+            }
+            return event
+        }
+    }
+
+    private func hide() {
+        if let keyMonitor { NSEvent.removeMonitor(keyMonitor) }
+        keyMonitor = nil
+        panel.orderOut(nil)
+    }
+
+    func windowDidResignKey(_ notification: Notification) {
+        hide()
+    }
+}

integrations/desktop/macos/Sources/CogneeDesktop/GlobalHotKey.swift

@@ -8,14 +8,18 @@ final class GlobalHotKey {
     private var hotKeyRef: EventHotKeyRef?
     private var eventHandler: EventHandlerRef?
     private let handler: () -> Void
+    private let id: UInt32
 
     /// Default binding: Option+Space (Command+Space stays with the system search).
+    /// Each registered hotkey needs its own ``id``.
     init?(
         keyCode: UInt32 = UInt32(kVK_Space),
         modifiers: UInt32 = UInt32(optionKey),
+        id: UInt32 = 1,
         handler: @escaping () -> Void
     ) {
         self.handler = handler
+        self.id = id
 
         var eventType = EventTypeSpec(
             eventClass: OSType(kEventClassKeyboard),
@@ -25,9 +29,26 @@ final class GlobalHotKey {
         var installedHandler: EventHandlerRef?
         let installStatus = InstallEventHandler(
             GetApplicationEventTarget(),
-            { _, _, userData -> OSStatus in
-                guard let userData else { return noErr }
+            { _, event, userData -> OSStatus in
+                guard let userData, let event else { return noErr }
+                // Every installed handler sees every hotkey press; without this
+                // check, whichever hotkey fires triggers ALL registered actions
+                // (and the last-installed one swallows the event). Dispatch on
+                // the pressed hotkey's ID and pass foreign events along.
+                var pressedID = EventHotKeyID()
+                GetEventParameter(
+                    event,
+                    EventParamName(kEventParamDirectObject),
+                    EventParamType(typeEventHotKeyID),
+                    nil,
+                    MemoryLayout<EventHotKeyID>.size,
+                    nil,
+                    &pressedID
+                )
                 let hotKey = Unmanaged<GlobalHotKey>.fromOpaque(userData).takeUnretainedValue()
+                guard pressedID.id == hotKey.id else {
+                    return OSStatus(eventNotHandledErr)
+                }
                 DispatchQueue.main.async { hotKey.handler() }
                 return noErr
             },
@@ -39,7 +60,7 @@ final class GlobalHotKey {
         guard installStatus == noErr else { return nil }
         eventHandler = installedHandler
 
-        let hotKeyID = EventHotKeyID(signature: OSType(0x4347_5350), id: 1)  // 'CGSP'
+        let hotKeyID = EventHotKeyID(signature: OSType(0x4347_5350), id: id)  // 'CGSP'
         var registeredRef: EventHotKeyRef?
         let registerStatus = RegisterEventHotKey(
             keyCode, modifiers, hotKeyID, GetApplicationEventTarget(), 0, &registeredRef