Select items by clicking the card instead of copying them

Copying was a side effect of a click, which made it impossible to build
a selection with the mouse and surprising when the intent was to pick
something up rather than copy it immediately. A click now selects (or
deselects), and copying is an explicit action from the selection bar or
the right-click menu.

AGENTS.md

@@ -27,14 +27,17 @@ clicking an item copies it back to the clipboard.
   `Images/` next to it, cached in an `NSCache`. Owns all mutations (add,
   toggle done, edit, delete, move, merge, clear done) and clipboard writes
   (`copy`, `copyAsList` for numbered output, `copyAsLines` for plain newlines;
-  both text modes skip image items). Saves on every mutation.
+  both text modes skip image items). Batch mutations (`delete(ids:)`,
+  `setDone(_:ids:)`, `move(ids:to:)`) back the selection context menu, so one
+  action applies to every selected item and image files are cleaned up once.
+  Saves on every mutation.
 - `Sources/Prompt/PanelView.swift` — the panel UI. Header (section switcher,
   search, add photos, close), item list, composer. Composer `# Name` creates/
-  switches sections. Click = copy; Cmd+click toggles multi-select, Shift+click
-  selects a range, and a selection bar offers Copy as List / Copy as Lines;
-  right-click = context menu (Copy, Copy as List, Copy as Lines, Done, Edit,
-  Open, Merge, Move To, Delete). Esc clears the selection before it hides the
-  panel. Drop target for images/files.
+  switches sections. Click = select (Shift+click for a range); the selection
+  bar offers Copy (single item), Copy as List and Copy as Lines; right-click =
+  context menu acting on the whole selection (Copy, Copy as List, Copy as
+  Lines, Done, Edit, Open, Merge, Move To, Delete). Esc clears the selection
+  before it hides the panel. Drop target for images/files.
 - `Sources/Prompt/PanelController.swift` — owns the floating `NSPanel`
   (`.nonactivatingPanel`, `.floating`, right-edge docked, frame autosaved as
   `PromptPanel`), the Cmd+V image-paste monitor, and `EditWindowController`
@@ -156,14 +159,25 @@ brew upgrade --cask prompt
 
 ## Gotchas
 
-- **Setting `NSApp.mainMenu` replaces SwiftUI's default menu.** SwiftUI installs
-  a menu containing the standard Edit items, and AppKit routes Cmd+C/V/X/A/Z
-  through those items — so a hand-built menu with only Hide/Quit silently
-  breaks pasting, copying and select-all in the composer. `setupMainMenu()`
-  therefore rebuilds an Edit menu with `undo:`/`redo:`/`cut:`/`copy:`/`paste:`/
-  `selectAll:` (nil targets, so they travel the responder chain to the field
-  editor). `Prompt --diag` dumps the menu so this can be checked without a
-  keyboard.
+- **Never assign `NSApp.mainMenu`.** SwiftUI installs a menu whose Edit items
+  are how AppKit routes Cmd+C/V/X/A/Z; replacing it with a hand-built menu
+  silently breaks pasting, copying and select-all in the composer (this shipped
+  once and had to be reverted). `installMenuItems()` only *augments* the
+  existing menu: it adds Hide Panel (Cmd+W) and removes SwiftUI's Settings item,
+  whose empty scene would otherwise shadow the in-panel Cmd+, sync panel.
+- **Cmd+V is handled by the paste monitor, not the menu.** The panel is a
+  `.nonactivatingPanel`, so it can be key while the app is not active, and menu
+  key equivalents are not reliably delivered in that state. The monitor
+  dispatches `paste:` to the responder chain itself for text, and adds the
+  clipboard image to the store when there is no text. `Prompt --diag` dumps the
+  menu so the wiring can be checked without a keyboard.
+- **A row is not a `Button`** because it contains a checkbox `Button`, and
+  nested buttons never receive clicks. The row uses `contentShape` +
+  `onTapGesture` so a click anywhere on the card selects it. Selection is
+  driven by the card click, the checkbox, Cmd+click (toggle) and Shift+click
+  (range); the context menu acts on the whole selection via `effectiveIDs(for:)`.
+  Copying is an explicit action (selection bar or context menu), never a side
+  effect of a click — that was changed deliberately.
 - **Never bind bare keys as `.keyboardShortcut` in the panel** (Space, Delete,
   plain Cmd+C). SwiftUI key equivalents are matched before text input and
   would steal characters from the composer TextField. Only Cmd-modified

README.md

@@ -2,20 +2,22 @@
 
 A native macOS app for keeping prompts and photos, in the spirit of
 [Copper](https://shadcn.com/copper) by shadcn: a floating panel that sits next
-to your work. Click anything to copy it back to your clipboard.
+to your work. Select what you need and send it back to your clipboard.
 
-- **Click to copy** — text notes go back as text, photos go back as images.
+- **Click to select** — clicking a card selects it (Shift+click for a range),
+  and the selection bar copies a single item as-is, or the whole selection as a
+  numbered list or as plain newline-separated lines.
+- **Text or photo** — copying sends text back as text and a photo back as an
+  image.
 - **Capture from anywhere** — select text in any app and tap **Left Shift twice**.
 - **Photos** — paste (Cmd+V), drag & drop, or add via the photo button.
 - **Workspaces** — type `# Name` in the composer, or use "New Workspace" in
   the Cmd+K switcher (which opens a name modal); Cmd+K switches, and the
   up/down arrows in the switcher reorder them. (The code and the saved JSON
   still call these `sections` so existing data keeps working.)
-- **Copy as List / Copy as Lines** — Cmd+click to multi-select (Shift+click for
-  a range), then copy the selection as a numbered list or as plain
-  newline-separated text, from the selection bar or the right-click menu.
-- **Merge Notes, Mark as Done, Edit, Move To** — right-click any item.
-- **Search** — Cmd+F searches across all sections.
+- **Right-click for actions** — Copy, Copy as List, Copy as Lines, Mark as Done,
+  Edit, Open, Merge Notes, Move To, Delete — each acting on the whole selection.
+- **Search** — Cmd+F searches across all workspaces.
 - **Sync (optional)** — generate an 8-digit code (`1234-5678`) on one Mac and
   enter it on the other; no account, no login. The code is the only secret.
 - **Local & private** — everything lives in

Sources/Prompt/App.swift

@@ -32,7 +32,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         // which locks the user out once the panel is hidden.
         if CommandLine.arguments.contains("--diag") {
             setupStatusItem()
-            setupMainMenu()
+            installMenuItems()
             DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
                 self.writeDiagnostics()
                 NSApp.terminate(nil)
@@ -60,9 +60,11 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         HotkeyManager.shared.start()
 
         setupStatusItem()
-        setupMainMenu()
         promptForAccessibilityIfNeeded()
 
+        // Let SwiftUI finish installing its main menu, then augment it.
+        DispatchQueue.main.async { self.installMenuItems() }
+
         // Show the panel on launch so the app is discoverable (it has no Dock
         // icon and the menu bar icon can be hard to spot on a full bar).
         Task { @MainActor in
@@ -111,44 +113,24 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         return .terminateNow
     }
 
-    /// Accessory apps have no visible menu bar, but the main menu still
-    /// services key equivalents — this is what makes Cmd+Q and Cmd+W work
-    /// while the panel has focus.
-    ///
-    /// The Edit menu is not decoration: AppKit routes Cmd+C/V/X/A/Z through
-    /// these items, so a minimal main menu silently breaks pasting and
-    /// selecting in the composer.
-    private func setupMainMenu() {
-        let mainMenu = NSMenu()
+    /// Adds "Hide Panel" to the menu SwiftUI already installed. Do NOT replace
+    /// `NSApp.mainMenu`: SwiftUI's menu carries the Edit items that AppKit
+    /// routes Cmd+C/V/X/A/Z through, so replacing it breaks text editing in the
+    /// composer. This only inserts one item and drops SwiftUI's Settings item,
+    /// whose empty scene would otherwise shadow the in-panel Cmd+, sync panel.
+    private func installMenuItems() {
+        guard let appMenu = NSApp.mainMenu?.items.first?.submenu else { return }
 
-        let appMenuItem = NSMenuItem()
-        mainMenu.addItem(appMenuItem)
-        let appMenu = NSMenu(title: "Prompt")
-        appMenuItem.submenu = appMenu
+        if let settings = appMenu.items.firstIndex(where: { $0.keyEquivalent == "," && $0.keyEquivalentModifierMask == [.command] }) {
+            appMenu.removeItem(at: settings)
+        }
+        guard !appMenu.items.contains(where: { $0.action == #selector(hidePanel) }) else { return }
 
         let hide = NSMenuItem(title: "Hide Panel", action: #selector(hidePanel), keyEquivalent: "w")
         hide.target = self
-        appMenu.addItem(hide)
-        appMenu.addItem(.separator())
-        let quit = NSMenuItem(title: "Quit Prompt", action: #selector(quit), keyEquivalent: "q")
-        quit.target = self
-        appMenu.addItem(quit)
-
-        let editMenuItem = NSMenuItem()
-        mainMenu.addItem(editMenuItem)
-        let editMenu = NSMenu(title: "Edit")
-        editMenuItem.submenu = editMenu
-
-        editMenu.addItem(withTitle: "Undo", action: Selector(("undo:")), keyEquivalent: "z")
-        let redo = editMenu.addItem(withTitle: "Redo", action: Selector(("redo:")), keyEquivalent: "z")
-        redo.keyEquivalentModifierMask = [.command, .shift]
-        editMenu.addItem(.separator())
-        editMenu.addItem(withTitle: "Cut", action: #selector(NSText.cut(_:)), keyEquivalent: "x")
-        editMenu.addItem(withTitle: "Copy", action: #selector(NSText.copy(_:)), keyEquivalent: "c")
-        editMenu.addItem(withTitle: "Paste", action: #selector(NSText.paste(_:)), keyEquivalent: "v")
-        editMenu.addItem(withTitle: "Select All", action: #selector(NSText.selectAll(_:)), keyEquivalent: "a")
-
-        NSApp.mainMenu = mainMenu
+        let quitIndex = appMenu.items.firstIndex { $0.action == #selector(NSApplication.terminate(_:)) } ?? appMenu.items.count
+        appMenu.insertItem(.separator(), at: quitIndex)
+        appMenu.insertItem(hide, at: quitIndex + 1)
     }
 
     @MainActor @objc private func hidePanel() {

Sources/Prompt/PanelController.swift

@@ -71,22 +71,28 @@ final class PanelController: NSObject {
         panel.setFrameOrigin(NSPoint(x: screen.maxX - size.width - 12, y: screen.minY + 12))
     }
 
-    // Intercept Cmd+V when the panel is key and the clipboard holds an image
-    // (and no text, so normal text paste into the composer is unaffected).
+    // Cmd+V is handled here rather than left to a menu key equivalent. The
+    // panel is a nonactivating panel, so it can be key while the app is not
+    // active, and menu key equivalents are not reliably delivered in that
+    // state — which is what silently broke pasting. Dispatching paste: to the
+    // responder chain ourselves removes that dependency.
     private func installPasteMonitor() {
         guard pasteMonitor == nil else { return }
         pasteMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { [weak self] event in
             guard let self, let panel = self.panel, event.window == panel else { return event }
             let modifiers = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
-            if modifiers == [.command], event.charactersIgnoringModifiers == "v" {
+            guard modifiers == [.command], event.charactersIgnoringModifiers == "v" else { return event }
+
             let pasteboard = NSPasteboard.general
-                if pasteboard.string(forType: .string) == nil,
-                   let images = pasteboard.readObjects(forClasses: [NSImage.self], options: nil) as? [NSImage],
+            if pasteboard.string(forType: .string) != nil {
+                NSApp.sendAction(#selector(NSText.paste(_:)), to: nil, from: nil)
+                return nil
+            }
+            if let images = pasteboard.readObjects(forClasses: [NSImage.self], options: nil) as? [NSImage],
                let image = images.first {
                 Task { @MainActor in Store.shared.addImage(image) }
                 return nil
             }
-            }
             return event
         }
     }

Sources/Prompt/PanelView.swift

@@ -193,8 +193,21 @@ struct PanelView: View {
         .padding(.vertical, 48)
     }
 
+    /// Rows carry a checkbox that *selects* the item, so a selection can be
+    /// copied or deleted from the context menu. The row cannot be a Button
+    /// because the checkbox is one, and nested buttons do not receive clicks.
     private func row(for item: PromptItem, sectionName: String) -> some View {
-        Button { handleClick(item) } label: {
+        HStack(alignment: .top, spacing: 8) {
+            Button {
+                toggleSelection(item.id)
+            } label: {
+                Image(systemName: selection.contains(item.id) ? "checkmark.circle.fill" : "circle")
+                    .font(.system(size: 15))
+                    .foregroundStyle(selection.contains(item.id) ? Color.accentColor : Color.secondary.opacity(0.55))
+            }
+            .buttonStyle(.plain)
+            .help(selection.contains(item.id) ? "Deselect" : "Select for copy or delete")
+
             VStack(alignment: .leading, spacing: 6) {
                 if !sectionName.isEmpty {
                     Text(sectionName.uppercased())
@@ -208,13 +221,12 @@ struct PanelView: View {
                         Text(sourceApp)
                     }
                     Text(item.createdAt, style: .time)
-                    if item.done {
-                        Image(systemName: "checkmark")
-                    }
                 }
                 .font(.caption2)
                 .foregroundStyle(.tertiary)
             }
+            .frame(maxWidth: .infinity, alignment: .leading)
+        }
         .padding(10)
         .frame(maxWidth: .infinity, alignment: .leading)
         .background(rowBackground(item))
@@ -228,9 +240,9 @@ struct PanelView: View {
                     .transition(.opacity)
             }
         }
-        }
-        .buttonStyle(.plain)
-        .help("Click to copy · Cmd+click to select several · Shift+click for a range · right-click for more")
+        .contentShape(Rectangle())
+        .onTapGesture { handleClick(item) }
+        .help("Click to select · Shift+click for a range · right-click to copy, delete and more")
         .contextMenu { contextMenu(for: item) }
     }
 
@@ -266,43 +278,51 @@ struct PanelView: View {
     }
 
     private func contextMenu(for item: PromptItem) -> some View {
-        Group {
+        let ids = effectiveIDs(for: item)
+        let multiple = ids.count > 1
+        return Group {
             Button("Copy") { copy(item) }
-            Button("Copy as List") {
-                store.copyAsList(ids: effectiveIDs(for: item))
+            Button(multiple ? "Copy \(ids.count) as List" : "Copy as List") {
+                store.copyAsList(ids: ids)
                 flashCopied(item.id)
             }
-            Button("Copy as Lines") {
-                store.copyAsLines(ids: effectiveIDs(for: item))
+            Button(multiple ? "Copy \(ids.count) as Lines" : "Copy as Lines") {
+                store.copyAsLines(ids: ids)
                 flashCopied(item.id)
             }
             Divider()
-            Button(item.done ? "Mark as Not Done" : "Mark as Done") { store.toggleDone(item.id) }
-            if case .text(let text) = item.content {
+            Button(item.done ? "Mark as Not Done" : "Mark as Done") {
+                store.setDone(!item.done, ids: ids)
+            }
+            if case .text(let text) = item.content, !multiple {
                 Button("Edit…") {
                     PanelController.shared.editController.edit(itemID: item.id, text: text)
                 }
             }
-            if case .image(let filename) = item.content {
+            if case .image(let filename) = item.content, !multiple {
                 Button("Open") {
                     NSWorkspace.shared.open(store.imageURL(for: filename))
                 }
             }
-            if selection.count > 1, selection.contains(item.id) {
+            if multiple {
                 Button("Merge Notes") {
-                    store.merge(ids: selection)
+                    store.merge(ids: ids)
                     clearSelection()
                 }
             }
             Menu("Move To") {
                 ForEach(store.sections.filter { $0.id != store.sectionID(of: item.id) }) { section in
-                    Button(section.name) { store.move(item.id, to: section.id) }
+                    Button(section.name) {
+                        store.move(ids: ids, to: section.id)
+                        if multiple { clearSelection() }
+                    }
                 }
             }
             Divider()
-            Button("Delete", role: .destructive) {
-                selection.remove(item.id)
-                store.delete(item.id)
+            Button(multiple ? "Delete \(ids.count) Items" : "Delete", role: .destructive) {
+                store.delete(ids: ids)
+                selection.subtract(ids)
+                lastSelectedID = nil
             }
         }
     }
@@ -541,6 +561,12 @@ struct PanelView: View {
                 .font(.caption)
                 .foregroundStyle(.secondary)
             Spacer()
+            if selection.count == 1, let id = selection.first, let item = store.item(id) {
+                Button("Copy") { copy(item) }
+                    .font(.caption)
+                    .buttonStyle(.plain)
+                    .foregroundStyle(Color.accentColor)
+            }
             Button("Copy as List") { copySelection(asList: true) }
                 .font(.caption)
                 .buttonStyle(.plain)
@@ -649,22 +675,25 @@ struct PanelView: View {
 
     // MARK: - Actions
 
+    /// A click anywhere on the card selects it (Shift+click selects a range).
+    /// Copying is then an action on the selection — from the selection bar or
+    /// the right-click menu — rather than the side effect of a click.
     private func handleClick(_ item: PromptItem) {
         let modifiers = NSApp.currentEvent?.modifierFlags ?? []
-        if modifiers.contains(.command) {
-            if selection.contains(item.id) {
-                selection.remove(item.id)
-            } else {
-                selection.insert(item.id)
-            }
-            lastSelectedID = item.id
-            return
-        }
         if modifiers.contains(.shift), let anchor = lastSelectedID, anchor != item.id {
             selectRange(from: anchor, to: item.id)
             return
         }
-        copy(item)
+        toggleSelection(item.id)
+    }
+
+    private func toggleSelection(_ id: UUID) {
+        if selection.contains(id) {
+            selection.remove(id)
+        } else {
+            selection.insert(id)
+        }
+        lastSelectedID = id
     }
 
     private func selectRange(from anchor: UUID, to target: UUID) {

Sources/Prompt/Store.swift

@@ -190,18 +190,49 @@ final class Store: ObservableObject {
     }
 
     func delete(_ id: UUID) {
+        delete(ids: [id])
+    }
+
+    /// Deletes every item in `ids` in one pass, cleaning up their image files.
+    func delete(ids: Set<UUID>) {
+        guard !ids.isEmpty else { return }
+        var removedAny = false
         for sectionIndex in sections.indices {
-            if let itemIndex = sections[sectionIndex].items.firstIndex(where: { $0.id == id }) {
-                let item = sections[sectionIndex].items[itemIndex]
+            for item in sections[sectionIndex].items where ids.contains(item.id) {
+                removedAny = true
                 if case .image(let filename) = item.content {
                     try? FileManager.default.removeItem(at: imagesDirectory.appendingPathComponent(filename))
                     imageCache.removeObject(forKey: filename as NSString)
                 }
-                sections[sectionIndex].items.remove(at: itemIndex)
+            }
+            sections[sectionIndex].items.removeAll { ids.contains($0.id) }
+        }
+        if removedAny { save() }
+    }
+
+    func setDone(_ done: Bool, ids: Set<UUID>) {
+        guard !ids.isEmpty else { return }
+        for sectionIndex in sections.indices {
+            for itemIndex in sections[sectionIndex].items.indices
+            where ids.contains(sections[sectionIndex].items[itemIndex].id) {
+                sections[sectionIndex].items[itemIndex].done = done
+            }
+        }
         save()
-                return
     }
+
+    /// Moves every item in `ids` into `targetSectionID`, keeping their order.
+    func move(ids: Set<UUID>, to targetSectionID: UUID) {
+        guard !ids.isEmpty,
+              let targetIndex = sections.firstIndex(where: { $0.id == targetSectionID }) else { return }
+        var moved: [PromptItem] = []
+        for sectionIndex in sections.indices where sectionIndex != targetIndex {
+            moved.append(contentsOf: sections[sectionIndex].items.filter { ids.contains($0.id) })
+            sections[sectionIndex].items.removeAll { ids.contains($0.id) }
         }
+        guard !moved.isEmpty else { return }
+        sections[targetIndex].items.append(contentsOf: moved)
+        save()
     }
 
     func move(_ id: UUID, to targetSectionID: UUID) {