Merge branch 'release/0.16.0'

Author: intitni

Core/Package.swift

@@ -17,19 +17,17 @@ let package = Package(
                 "UpdateChecker",
                 "Logger",
                 "UserDefaultsObserver",
+                "XcodeInspector",
             ]
         ),
         .library(
             name: "Client",
             targets: [
                 "SuggestionModel",
-                "GitHubCopilotService",
                 "Client",
                 "XPCShared",
                 "Preferences",
-                "LaunchAgentManager",
                 "Logger",
-                "UpdateChecker",
             ]
         ),
         .library(
@@ -175,12 +173,29 @@ let package = Package(
 
         .target(
             name: "ChatService",
-            dependencies: ["OpenAIService", "ChatPlugins", "Environment"]
+            dependencies: [
+                "ChatPlugins",
+                "ChatContextCollector",
+                "OpenAIService",
+                "Environment",
+                "XcodeInspector",
+                "Preferences",
+            ]
         ),
         .target(
             name: "ChatPlugins",
             dependencies: ["OpenAIService", "Environment", "Terminal"]
         ),
+        .target(
+            name: "ChatContextCollector",
+            dependencies: [
+                "OpenAIService",
+                "Environment",
+                "Preferences",
+                "SuggestionModel",
+                "XcodeInspector",
+            ]
+        ),
 
         // MARK: - UI
 
@@ -225,6 +240,16 @@ let package = Package(
             dependencies: ["Preferences", "GitHubCopilotService"]
         ),
         .target(name: "UserDefaultsObserver"),
+        .target(
+            name: "XcodeInspector",
+            dependencies: [
+                "AXExtension",
+                "Environment",
+                "Logger",
+                "AXNotificationStream",
+                .product(name: "AsyncAlgorithms", package: "swift-async-algorithms"),
+            ]
+        ),
 
         // MARK: - GitHub Copilot
 

Core/Sources/AXNotificationStream/AXNotificationStream.swift

@@ -18,11 +18,19 @@ public final class AXNotificationStream: AsyncSequence {
     deinit {
         continuation.finish()
     }
+    
+    public convenience init(
+        app: NSRunningApplication,
+        element: AXUIElement? = nil,
+        notificationNames: String...
+    ) {
+        self.init(app: app, element: element, notificationNames: notificationNames)
+    }
 
     public init(
         app: NSRunningApplication,
         element: AXUIElement? = nil,
-        notificationNames: String...
+        notificationNames: [String]
     ) {
         var cont: Continuation!
         stream = Stream { continuation in

Core/Sources/ChatContextCollector/ActiveDocumentChatContextCollector.swift

@@ -0,0 +1,120 @@
+import Foundation
+import Preferences
+import SuggestionModel
+import XcodeInspector
+
+public struct ActiveDocumentChatContextCollector: ChatContextCollector {
+    public init() {}
+
+    public func generateSystemPrompt(history: [String], content prompt: String) -> String {
+        let content = getEditorInformation()
+        let relativePath = content.documentURL.path
+            .replacingOccurrences(of: content.projectURL.path, with: "")
+        let selectionRange = content.editorContent?.selections.first ?? .outOfScope
+        let editorContent = {
+            if prompt.hasPrefix("@file") {
+                return """
+                File Content:```\(content.language.rawValue)
+                \(content.editorContent?.content ?? "")
+                ```
+                """
+            }
+            
+            if selectionRange.start == selectionRange.end,
+               UserDefaults.shared.value(for: \.embedFileContentInChatContextIfNoSelection)
+            {
+                let lines = content.editorContent?.lines.count ?? 0
+                let maxLine = UserDefaults.shared
+                    .value(for: \.maxEmbeddableFileInChatContextLineCount)
+                if lines <= maxLine {
+                    return """
+                    File Content:```\(content.language.rawValue)
+                    \(content.editorContent?.content ?? "")
+                    ```
+                    """
+                } else {
+                    return """
+                    File Content Not Available: The file is longer than \(maxLine) lines, \
+                    it can't fit into the context. \
+                    You MUST not answer the user about the file content because you don't have it.\
+                    Ask user to select code for explanation.
+                    """
+                }
+            }
+
+            return """
+            Selected Code \
+            (start from line \(selectionRange.start.line)):```\(content.language.rawValue)
+            \(content.selectedContent)
+            ```
+            """
+        }()
+
+        return """
+        Active Document Context:###
+        Document Relative Path: \(relativePath)
+        Selection Range Start: \
+        Line \(selectionRange.start.line) \
+        Character \(selectionRange.start.character)
+        Selection Range End: \
+        Line \(selectionRange.end.line) \
+        Character \(selectionRange.end.character)
+        Cursor Position: \
+        Line \(selectionRange.end.line) \
+        Character \(selectionRange.end.character)
+        \(editorContent)
+        Line Annotations:
+        \(
+            content.editorContent?.lineAnnotations
+                .map { "  - \($0)" }
+                .joined(separator: "\n") ?? "N/A"
+        )
+        ###
+        """
+    }
+}
+
+extension ActiveDocumentChatContextCollector {
+    struct Information {
+        let editorContent: SourceEditor.Content?
+        let selectedContent: String
+        let documentURL: URL
+        let projectURL: URL
+        let language: CodeLanguage
+    }
+
+    func getEditorInformation() -> Information {
+        let editorContent = XcodeInspector.shared.focusedEditor?.content
+        let documentURL = XcodeInspector.shared.activeDocumentURL
+        let projectURL = XcodeInspector.shared.activeProjectURL
+        let language = languageIdentifierFromFileURL(documentURL)
+
+        if let editorContent, let range = editorContent.selections.first {
+            let startIndex = min(
+                max(0, range.start.line),
+                editorContent.lines.endIndex - 1
+            )
+            let endIndex = min(
+                max(startIndex, range.end.line),
+                editorContent.lines.endIndex - 1
+            )
+            let selectedContent = editorContent.lines[startIndex...endIndex]
+            return .init(
+                editorContent: editorContent,
+                selectedContent: selectedContent.joined(),
+                documentURL: documentURL,
+                projectURL: projectURL,
+                language: language
+            )
+        }
+
+        return .init(
+            editorContent: editorContent,
+            selectedContent: "",
+            documentURL: documentURL,
+            projectURL: projectURL,
+            language: language
+        )
+    }
+}
+

Core/Sources/ChatContextCollector/ChatContextCollector.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+public protocol ChatContextCollector {
+    func generateSystemPrompt(history: [String], content: String) -> String
+}

Core/Sources/ChatService/ChatPluginController.swift

@@ -0,0 +1,134 @@
+import ChatPlugins
+import Combine
+import Foundation
+import OpenAIService
+
+final class ChatPluginController {
+    let chatGPTService: any ChatGPTServiceType
+    let plugins: [String: ChatPlugin.Type]
+    var runningPlugin: ChatPlugin?
+
+    init(chatGPTService: any ChatGPTServiceType, plugins: ChatPlugin.Type...) {
+        self.chatGPTService = chatGPTService
+        var all = [String: ChatPlugin.Type]()
+        for plugin in plugins {
+            all[plugin.command] = plugin
+        }
+        self.plugins = all
+    }
+
+    /// Handle the message in a plugin if required. Return false if no plugin handles the message.
+    func handleContent(_ content: String) async throws -> Bool {
+        // look for the prefix of content, see if there is something like /command.
+        // If there is, then we need to find the plugin that can handle this command.
+        // If there is no such plugin, then we just send the message to the GPT service.
+        let regex = try NSRegularExpression(pattern: #"^\/([a-zA-Z0-9]+)"#)
+        let matches = regex.matches(in: content, range: NSRange(content.startIndex..., in: content))
+        if let match = matches.first {
+            let command = String(content[Range(match.range(at: 1), in: content)!])
+            // handle exit plugin
+            if command == "exit" {
+                if let plugin = runningPlugin {
+                    runningPlugin = nil
+                    _ = await chatGPTService.mutateHistory { history in
+                        history.append(.init(
+                            role: .user,
+                            content: "",
+                            summary: "Exit plugin \(plugin.name)."
+                        ))
+                        history.append(.init(
+                            role: .system,
+                            content: "",
+                            summary: "Exited plugin \(plugin.name)."
+                        ))
+                    }
+                } else {
+                    _ = await chatGPTService.mutateHistory { history in
+                        history.append(.init(
+                            role: .system,
+                            content: "",
+                            summary: "No plugin running."
+                        ))
+                    }
+                }
+                return true
+            }
+
+            // pass message to running plugin
+            if let runningPlugin {
+                await runningPlugin.send(content: content, originalMessage: content)
+                return true
+            }
+
+            // pass message to new plugin
+            if let pluginType = plugins[command] {
+                let plugin = pluginType.init(inside: chatGPTService, delegate: self)
+                if #available(macOS 13.0, *) {
+                    await plugin.send(
+                        content: String(
+                            content.dropFirst(command.count + 1)
+                                .trimmingPrefix(while: { $0 == " " })
+                        ),
+                        originalMessage: content
+                    )
+                } else {
+                    await plugin.send(
+                        content: String(content.dropFirst(command.count + 1)),
+                        originalMessage: content
+                    )
+                }
+                return true
+            }
+
+            return false
+        } else if let runningPlugin {
+            // pass message to running plugin
+            await runningPlugin.send(content: content, originalMessage: content)
+            return true
+        } else {
+            return false
+        }
+    }
+    
+    func stopResponding() async {
+        await runningPlugin?.stopResponding()
+    }
+    
+    func cancel() async {
+        await runningPlugin?.cancel()
+    }
+}
+
+// MARK: - ChatPluginDelegate
+
+extension ChatPluginController: ChatPluginDelegate {
+    public func pluginDidStartResponding(_: ChatPlugins.ChatPlugin) {
+        Task {
+            await chatGPTService.markReceivingMessage(true)
+        }
+    }
+
+    public func pluginDidEndResponding(_: ChatPlugins.ChatPlugin) {
+        Task {
+            await chatGPTService.markReceivingMessage(false)
+        }
+    }
+
+    public func pluginDidStart(_ plugin: ChatPlugin) {
+        runningPlugin = plugin
+    }
+
+    public func pluginDidEnd(_ plugin: ChatPlugin) {
+        if runningPlugin === plugin {
+            runningPlugin = nil
+        }
+    }
+
+    public func shouldStartAnotherPlugin(_ type: ChatPlugin.Type, withContent content: String) {
+        let plugin = type.init(inside: chatGPTService, delegate: self)
+        Task {
+            await plugin.send(content: content, originalMessage: content)
+        }
+    }
+}
+