Merge pull request #188 from theJayTea/macOS-v4_4

macOS v4

Author: theJayTea

macOS/Latest_Version_for_Update_Check.txt

@@ -1 +1 @@
-3.1
+4.0

macOS/writing-tools.xcodeproj/project.pbxproj

@@ -60,13 +60,148 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
 
         }
 
+        // Register the main popup shortcut
         KeyboardShortcuts.onKeyUp(for: .showPopup) { [weak self] in
             if !AppSettings.shared.hotkeysPaused {
                 self?.showPopup()
             } else {
                 NSLog("Hotkeys are paused")
             }
         }
+        
+        // Set up command-specific shortcuts
+        setupCommandShortcuts()
+        
+        // Register for command changes to update shortcuts
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(setupCommandShortcuts),
+            name: NSNotification.Name("CommandsChanged"),
+            object: nil
+        )
+    }
+    
+    // Setup and register all command shortcuts
+    @objc private func setupCommandShortcuts() {
+        // Only reset shortcuts for commands that should not have shortcuts
+        for command in appState.commandManager.commands.filter({ !$0.hasShortcut }) {
+            KeyboardShortcuts.reset(.commandShortcut(for: command.id))
+        }
+        
+        // Register handlers for commands with shortcuts enabled
+        for command in appState.commandManager.commands.filter({ $0.hasShortcut }) {
+            KeyboardShortcuts.onKeyUp(for: .commandShortcut(for: command.id)) { [weak self] in
+                guard let self = self, !AppSettings.shared.hotkeysPaused else { return }
+                
+                // Execute the command directly
+                self.executeCommandDirectly(command)
+            }
+        }
+    }
+    
+    // Executes a command without showing the popup
+    private func executeCommandDirectly(_ command: CommandModel) {
+        // Cancel any ongoing processing first
+        appState.activeProvider.cancel()
+        
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            
+            // Save the current app so we can return to it
+            if let currentFrontmostApp = NSWorkspace.shared.frontmostApplication {
+                self.appState.previousApplication = currentFrontmostApp
+            }
+            
+            let generalPasteboard = NSPasteboard.general
+            
+            // Get initial pasteboard content to restore later
+            let oldContents = generalPasteboard.string(forType: .string)
+            
+            // Clear and perform copy command to get selected text
+            generalPasteboard.clearContents()
+            let source = CGEventSource(stateID: .hidSystemState)
+            let keyDown = CGEvent(keyboardEventSource: source, virtualKey: 0x08, keyDown: true)
+            let keyUp = CGEvent(keyboardEventSource: source, virtualKey: 0x08, keyDown: false)
+            keyDown?.flags = .maskCommand
+            keyUp?.flags = .maskCommand
+            keyDown?.post(tap: .cghidEventTap)
+            keyUp?.post(tap: .cghidEventTap)
+            
+            // Wait for copy operation to complete
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+                guard let self = self else { return }
+                
+                // Get the selected text
+                let selectedText = generalPasteboard.string(forType: .string) ?? ""
+                
+                // Restore original clipboard contents
+                generalPasteboard.clearContents()
+                if let oldContents = oldContents {
+                    generalPasteboard.setString(oldContents, forType: .string)
+                }
+                
+                // Skip if no text is selected
+                guard !selectedText.isEmpty else {
+                    NSLog("No text selected for command: \(command.name)")
+                    return
+                }
+                
+                // Store the selected text in app state
+                self.appState.selectedText = selectedText
+                
+                // Process the command
+                Task {
+                    await self.processCommandWithUI(command)
+                }
+            }
+        }
+    }
+    
+    // Process a command with appropriate UI feedback
+    private func processCommandWithUI(_ command: CommandModel) async {
+        // Set processing flag to prevent duplicate operations
+        if appState.isProcessing {
+            return
+        }
+        
+        appState.isProcessing = true
+        
+        do {
+            // Process the text with the AI provider
+            let result = try await appState.activeProvider.processText(
+                systemPrompt: command.prompt,
+                userPrompt: appState.selectedText,
+                images: [],
+                streaming: false
+            )
+            
+            // Handle the result
+            await MainActor.run {
+                if command.useResponseWindow {
+                    // Show in response window
+                    let window = ResponseWindow(
+                        title: command.name,
+                        content: result,
+                        selectedText: appState.selectedText,
+                        option: nil
+                    )
+                    
+                    NSApp.activate(ignoringOtherApps: true)
+                    WindowManager.shared.addResponseWindow(window)
+                    window.makeKeyAndOrderFront(nil)
+                    window.orderFrontRegardless()
+                } else {
+                    // Replace text directly
+                    appState.replaceSelectedText(with: result)
+                }
+            }
+        } catch {
+            print("Error processing command \(command.name): \(error.localizedDescription)")
+        }
+        
+        await MainActor.run {
+            appState.isProcessing = false
+        }
     }
 
     // Called when app is about to close - performs cleanup
@@ -227,85 +362,112 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
         }
     }
 
-    // Shows the main popup window when shortcut is triggered
     @MainActor private func showPopup() {
-        appState.activeProvider.cancel()
-        
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            
-            if let currentFrontmostApp = NSWorkspace.shared.frontmostApplication {
-                self.appState.previousApplication = currentFrontmostApp
-            }
-            
-            self.closePopupWindow()
-            
-            let generalPasteboard = NSPasteboard.general
-            
-            // Get initial pasteboard content
-            let oldContents = generalPasteboard.string(forType: .string)
-            
-            // Prioritized image types (in order of preference)
-            let supportedImageTypes = [
-                NSPasteboard.PasteboardType("public.png"),
-                NSPasteboard.PasteboardType("public.jpeg"),
-                NSPasteboard.PasteboardType("public.tiff"),
-                NSPasteboard.PasteboardType("com.compuserve.gif"),
-                NSPasteboard.PasteboardType("public.image")
-            ]
-            var foundImage: Data? = nil
+            appState.activeProvider.cancel()
 
-            // Try to find the first available image in order of preference
-            for type in supportedImageTypes {
-                if let data = generalPasteboard.data(forType: type) {
-                    foundImage = data
-                    NSLog("Selected image type: \(type)")
-                    break // Take only the first matching format
-                }
-            }
-            
-            // Clear and perform copy command
-            generalPasteboard.clearContents()
-            let source = CGEventSource(stateID: .hidSystemState)
-            let keyDown = CGEvent(keyboardEventSource: source, virtualKey: 0x08, keyDown: true)
-            let keyUp = CGEvent(keyboardEventSource: source, virtualKey: 0x08, keyDown: false)
-            keyDown?.flags = .maskCommand
-            keyUp?.flags = .maskCommand
-            keyDown?.post(tap: .cghidEventTap)
-            keyUp?.post(tap: .cghidEventTap)
-            
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+            DispatchQueue.main.async { [weak self] in
                 guard let self = self else { return }
-                let selectedText = generalPasteboard.string(forType: .string) ?? ""
-                
-                // Update app state with found image if any
-                self.appState.selectedImages = foundImage.map { [$0] } ?? []
 
-                generalPasteboard.clearContents()
-                if let oldContents = oldContents {
-                    generalPasteboard.setString(oldContents, forType: .string)
+                if let currentFrontmostApp = NSWorkspace.shared.frontmostApplication {
+                    self.appState.previousApplication = currentFrontmostApp
                 }
 
-                let window = PopupWindow(appState: self.appState)
-                window.delegate = self
+                self.closePopupWindow()
 
-                self.appState.selectedText = selectedText
-                self.popupWindow = window
+                let generalPasteboard = NSPasteboard.general
+                let oldContents = generalPasteboard.string(forType: .string)
 
-                // Set appropriate window size based on content
-                if !selectedText.isEmpty || !self.appState.selectedImages.isEmpty {
-                    window.setContentSize(NSSize(width: 400, height: 400))
-                } else {
-                    window.setContentSize(NSSize(width: 400, height: 100))
-                }
+                // Clear and perform copy command to get current selection
+                generalPasteboard.clearContents()
+                let source = CGEventSource(stateID: .hidSystemState)
+                let keyDown = CGEvent(keyboardEventSource: source, virtualKey: 0x08, keyDown: true)
+                let keyUp = CGEvent(keyboardEventSource: source, virtualKey: 0x08, keyDown: false)
+                keyDown?.flags = .maskCommand
+                keyUp?.flags = .maskCommand
+                keyDown?.post(tap: .cghidEventTap)
+                keyUp?.post(tap: .cghidEventTap)
 
-                window.positionNearMouse()
-                NSApp.activate(ignoringOtherApps: true)
-                window.makeKeyAndOrderFront(nil)
-                window.orderFrontRegardless()
+                // Wait for the copy operation to complete, then process the pasteboard
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) { [weak self] in
+                    guard let self = self else { return }
+                    
+                    var foundImages: [Data] = []
+                    var selectedText = ""
+                    
+                    // First check for file URLs (for Finder selections)
+                    let classes = [NSURL.self]
+                    let options: [NSPasteboard.ReadingOptionKey: Any] = [
+                        .urlReadingFileURLsOnly: true,
+                        .urlReadingContentsConformToTypes: [
+                            "public.image",
+                            "public.png",
+                            "public.jpeg",
+                            "public.tiff",
+                            "com.compuserve.gif"
+                        ]
+                    ]
+                    
+                    if let urls = generalPasteboard.readObjects(forClasses: classes, options: options) as? [URL] {
+                        for url in urls {
+                            if let imageData = try? Data(contentsOf: url) {
+                                if NSImage(data: imageData) != nil {
+                                    foundImages.append(imageData)
+                                    NSLog("Loaded image data from file: \(url.lastPathComponent)")
+                                }
+                            }
+                        }
+                    }
+                    
+                    // If no file URLs found, check for direct image data
+                    if foundImages.isEmpty {
+                        let supportedImageTypes = [
+                            NSPasteboard.PasteboardType("public.png"),
+                            NSPasteboard.PasteboardType("public.jpeg"),
+                            NSPasteboard.PasteboardType("public.tiff"),
+                            NSPasteboard.PasteboardType("com.compuserve.gif"),
+                            NSPasteboard.PasteboardType("public.image")
+                        ]
+                        
+                        for type in supportedImageTypes {
+                            if let data = generalPasteboard.data(forType: type) {
+                                foundImages.append(data)
+                                NSLog("Found direct image data of type: \(type)")
+                                break
+                            }
+                        }
+                    }
+                    
+                    // Get any text content
+                    selectedText = generalPasteboard.string(forType: .string) ?? ""
+                    
+                    // Restore original pasteboard contents
+                    generalPasteboard.clearContents()
+                    if let oldContents = oldContents {
+                        generalPasteboard.setString(oldContents, forType: .string)
+                    }
+                    
+                    // Update app state and show popup
+                    self.appState.selectedImages = foundImages
+                    self.appState.selectedText = selectedText
+                    
+                    let window = PopupWindow(appState: self.appState)
+                    window.delegate = self
+                    self.popupWindow = window
+                    
+                    // Set window size based on content
+                    if !selectedText.isEmpty || !foundImages.isEmpty {
+                        window.setContentSize(NSSize(width: 400, height: 400))
+                    } else {
+                        window.setContentSize(NSSize(width: 400, height: 100))
+                    }
+                    
+                    window.positionNearMouse()
+                    NSApp.activate(ignoringOtherApps: true)
+                    window.makeKeyAndOrderFront(nil)
+                    window.orderFrontRegardless()
+                }
             }
         }
-    }
 
     // Closes and cleans up the popup window
     private func closePopupWindow() {

macOS/writing-tools/App/AppDelegate.swift

@@ -8,9 +8,8 @@ class AppSettings: ObservableObject {
 
     // MARK: - Published Settings
     @Published var themeStyle: String {
-        didSet { 
-            defaults.set(themeStyle, forKey: "theme_style") 
-            // Also update the useGradientTheme flag for backward compatibility
+        didSet {
+            defaults.set(themeStyle, forKey: "theme_style")
             useGradientTheme = (themeStyle != "standard")
         }
     }
@@ -23,6 +22,10 @@ class AppSettings: ObservableObject {
         didSet { defaults.set(geminiModel.rawValue, forKey: "gemini_model") }
     }
 
+    @Published var geminiCustomModel: String {
+        didSet { defaults.set(geminiCustomModel, forKey: "gemini_custom_model") }
+    }
+    
     @Published var openAIApiKey: String {
         didSet { defaults.set(openAIApiKey, forKey: "openai_api_key") }
     }
@@ -96,6 +99,9 @@ class AppSettings: ObservableObject {
         didSet { defaults.set(ollamaKeepAlive, forKey: "ollama_keep_alive") }
     }
 
+    @Published var ollamaImageMode: OllamaImageMode {
+        didSet { defaults.set(ollamaImageMode.rawValue, forKey: "ollama_image_mode") }
+    }
 
     // MARK: - Init
     private init() {
@@ -109,6 +115,8 @@ class AppSettings: ObservableObject {
         let geminiModelStr = defaults.string(forKey: "gemini_model") ?? GeminiModel.twoflash.rawValue
         self.geminiModel = GeminiModel(rawValue: geminiModelStr) ?? .twoflash
 
+        self.geminiCustomModel = defaults.string(forKey: "gemini_custom_model") ?? ""
+        
         self.openAIApiKey = defaults.string(forKey: "openai_api_key") ?? ""
         self.openAIBaseURL = defaults.string(forKey: "openai_base_url") ?? OpenAIConfig.defaultBaseURL
         self.openAIModel = defaults.string(forKey: "openai_model") ?? OpenAIConfig.defaultModel
@@ -132,6 +140,9 @@ class AppSettings: ObservableObject {
         self.hotKeyCode = defaults.integer(forKey: "hotKey_keyCode")
         self.hotKeyModifiers = defaults.integer(forKey: "hotKey_modifiers")
         self.hotkeysPaused = defaults.bool(forKey: "hotkeys_paused")
+        
+        let ollamaImageModeRaw = defaults.string(forKey: "ollama_image_mode") ?? OllamaImageMode.ocr.rawValue
+        self.ollamaImageMode = OllamaImageMode(rawValue: ollamaImageModeRaw) ?? .ocr
     }
 
     // MARK: - Convenience