Merge branch 'feature/widget-read-cache-from-filespace' into develop

Author: intitni

Core/Sources/ChatPlugins/ChatPlugin.swift

@@ -6,7 +6,7 @@ public protocol ChatPlugin {
     static var command: String { get }
     var name: String { get }
 
-    init(inside chatGPTService: ChatGPTServiceType, delegate: ChatPluginDelegate)
+    init(inside chatGPTService: any ChatGPTServiceType, delegate: ChatPluginDelegate)
     func send(content: String) async
     func cancel() async
     func stopResponding() async

Core/Sources/ChatPlugins/TerminalChatPlugin.swift

@@ -7,12 +7,12 @@ public actor TerminalChatPlugin: ChatPlugin {
     public static var command: String { "run" }
     public nonisolated var name: String { "Terminal" }
 
-    let chatGPTService: ChatGPTServiceType
+    let chatGPTService: any ChatGPTServiceType
     var terminal: TerminalType = Terminal()
     var isCancelled = false
     weak var delegate: ChatPluginDelegate?
 
-    public init(inside chatGPTService: ChatGPTServiceType, delegate: ChatPluginDelegate) {
+    public init(inside chatGPTService: any ChatGPTServiceType, delegate: ChatPluginDelegate) {
         self.chatGPTService = chatGPTService
         self.delegate = delegate
     }

Core/Sources/ChatService/ChatService.swift

@@ -1,18 +1,24 @@
 import ChatPlugins
+import Combine
 import Foundation
 import OpenAIService
 
 public final class ChatService: ObservableObject {
-    let chatGPTService: ChatGPTServiceType
+    public let chatGPTService: any ChatGPTServiceType
     let plugins = registerPlugins(
         TerminalChatPlugin.self
     )
     var runningPlugin: ChatPlugin?
+    var cancellable = Set<AnyCancellable>()
 
-    public init(chatGPTService: ChatGPTServiceType) {
+    public init<T: ChatGPTServiceType>(chatGPTService: T) {
         self.chatGPTService = chatGPTService
+
+        chatGPTService.objectWillChange.sink { [weak self] _ in
+            self?.objectWillChange.send()
+        }.store(in: &cancellable)
     }
-    
+
     public func send(content: String) async throws {
         // 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.
@@ -43,26 +49,30 @@ public final class ChatService: ObservableObject {
         }
         await chatGPTService.clearHistory()
     }
+
+    public func mutateSystemPrompt(_ newPrompt: String) async {
+        await chatGPTService.mutateSystemPrompt(newPrompt)
+    }
 }
 
 extension ChatService: ChatPluginDelegate {
-    public func pluginDidStartResponding(_ plugin: ChatPlugins.ChatPlugin) {
+    public func pluginDidStartResponding(_: ChatPlugins.ChatPlugin) {
         Task {
             await chatGPTService.markReceivingMessage(true)
         }
     }
-    
-    public func pluginDidEndResponding(_ plugin: ChatPlugins.ChatPlugin) {
+
+    public func pluginDidEndResponding(_: ChatPlugins.ChatPlugin) {
         Task {
             await chatGPTService.markReceivingMessage(false)
         }
     }
-    
+
     public func pluginDidStart(_ plugin: ChatPlugin) {
         runningPlugin = plugin
     }
-    
-    public func pluginDidEnd(_ plugin: ChatPlugin) {
+
+    public func pluginDidEnd(_: ChatPlugin) {
         runningPlugin = nil
     }
 }

Core/Sources/OpenAIService/ChatGPTService.swift

@@ -1,7 +1,10 @@
 import AsyncAlgorithms
 import Foundation
+import Preferences
 
-public protocol ChatGPTServiceType {
+public protocol ChatGPTServiceType: ObservableObject {
+    var isReceivingMessage: Bool { get async }
+    var history: [ChatMessage] { get async }
     func send(content: String, summary: String?) async throws -> AsyncThrowingStream<String, Error>
     func stopReceivingMessage() async
     func clearHistory() async
@@ -49,13 +52,31 @@ public struct ChatGPTError: Error, Codable, LocalizedError {
     }
 }
 
-public actor ChatGPTService: ChatGPTServiceType, ObservableObject {
-    public var temperature: Double
-    public var model: String
-    public var endpoint: String
-    public var apiKey: String
+public actor ChatGPTService: ChatGPTServiceType {
     public var systemPrompt: String
-    public var maxToken: Int
+    public var temperature: Double
+
+    public var model: String {
+        let value = UserDefaults.shared.value(for: \.chatGPTModel)
+        if value.isEmpty { return "gpt-3.5-turbo" }
+        return value
+    }
+
+    public var endpoint: String {
+        let value = UserDefaults.shared.value(for: \.chatGPTEndpoint)
+        if value.isEmpty { return "https://api.openai.com/v1/chat/completions" }
+
+        return value
+    }
+
+    public var apiKey: String {
+        UserDefaults.shared.value(for: \.openAIAPIKey)
+    }
+
+    public var maxToken: Int {
+        UserDefaults.shared.value(for: \.chatGPTMaxToken)
+    }
+
     public var history: [ChatMessage] = [] {
         didSet { objectWillChange.send() }
     }
@@ -69,19 +90,11 @@ public actor ChatGPTService: ChatGPTServiceType, ObservableObject {
     var buildCompletionStreamAPI: CompletionStreamAPIBuilder = OpenAICompletionStreamAPI.init
 
     public init(
-        systemPrompt: String,
-        apiKey: String,
-        endpoint: String? = nil,
-        model: String? = nil,
-        temperature: Double = 1,
-        maxToken: Int = 2048
+        systemPrompt: String = "",
+        temperature: Double = 1
     ) {
         self.systemPrompt = systemPrompt
-        self.apiKey = apiKey
-        self.model = model ?? "gpt-3.5-turbo"
         self.temperature = temperature
-        self.maxToken = maxToken
-        self.endpoint = endpoint ?? "https://api.openai.com/v1/chat/completions"
     }
 
     public func send(

Core/Sources/Service/GUI/ChatProvider+Service.swift

@@ -0,0 +1,55 @@
+import ChatService
+import Foundation
+import OpenAIService
+import SuggestionWidget
+
+extension ChatProvider {
+    convenience init(service: ChatService, fileURL: URL, onCloseChat: @escaping () -> Void) {
+        self.init()
+        let cancellable = service.objectWillChange.sink { [weak self] in
+            guard let self else { return }
+            Task { @MainActor in
+                self.history = (await service.chatGPTService.history).map { message in
+                    .init(
+                        id: message.id,
+                        isUser: message.role == .user,
+                        text: message.summary ?? message.content
+                    )
+                }
+                self.isReceivingMessage = await service.chatGPTService.isReceivingMessage
+            }
+        }
+        
+        service.objectWillChange.send()
+
+        onMessageSend = { [cancellable] message in
+            _ = cancellable
+            Task {
+                do {
+                    _ = try await service.send(content: message)
+                } catch {
+                    PresentInWindowSuggestionPresenter().presentError(error)
+                }
+            }
+        }
+        onStop = {
+            Task {
+                await service.stopReceivingMessage()
+            }
+        }
+
+        onClear = {
+            Task {
+                await service.clearHistory()
+            }
+        }
+
+        onClose = {
+            Task {
+                await service.stopReceivingMessage()
+                PresentInWindowSuggestionPresenter().closeChatRoom(fileURL: fileURL)
+                onCloseChat()
+            }
+        }
+    }
+}

Core/Sources/Service/GUI/GraphicalUserInterfaceController.swift.swift

@@ -9,33 +9,7 @@ public final class GraphicalUserInterfaceController {
     nonisolated let suggestionWidget = SuggestionWidgetController()
     private nonisolated init() {
         Task { @MainActor in
-            suggestionWidget.onNextButtonTapped = {
-                Task { @ServiceActor in
-                    let handler = PseudoCommandHandler()
-                    await handler.presentNextSuggestion()
-                }
-            }
-
-            suggestionWidget.onPreviousButtonTapped = {
-                Task { @ServiceActor in
-                    let handler = PseudoCommandHandler()
-                    await handler.presentPreviousSuggestion()
-                }
-            }
-
-            suggestionWidget.onRejectButtonTapped = {
-                Task { @ServiceActor in
-                    let handler = PseudoCommandHandler()
-                    await handler.rejectSuggestions()
-                }
-            }
-
-            suggestionWidget.onAcceptButtonTapped = {
-                Task { @ServiceActor in
-                    let handler = PseudoCommandHandler()
-                    await handler.acceptSuggestion()
-                }
-            }
+            suggestionWidget.dataSource = WidgetDataSource.shared
         }
     }
 }

Core/Sources/Service/GUI/WidgetDataSource.swift

@@ -0,0 +1,78 @@
+import ChatService
+import Foundation
+import SuggestionWidget
+
+final class WidgetDataSource: SuggestionWidgetDataSource {
+    static let shared = WidgetDataSource()
+
+    private init() {}
+
+    func suggestionForFile(at url: URL) async -> SuggestionProvider? {
+        for workspace in await workspaces.values {
+            if let filespace = await workspace.filespaces[url],
+               let suggestion = await filespace.presentingSuggestion
+            {
+                return .init(
+                    code: suggestion.text,
+                    language: await filespace.language,
+                    startLineIndex: suggestion.position.line,
+                    suggestionCount: await filespace.suggestions.count,
+                    currentSuggestionIndex: await filespace.suggestionIndex,
+                    onSelectPreviousSuggestionTapped: {
+                        Task { @ServiceActor in
+                            let handler = PseudoCommandHandler()
+                            await handler.presentPreviousSuggestion()
+                        }
+                    },
+                    onSelectNextSuggestionTapped: {
+                        Task { @ServiceActor in
+                            let handler = PseudoCommandHandler()
+                            await handler.presentNextSuggestion()
+                        }
+                    },
+                    onRejectSuggestionTapped: {
+                        Task { @ServiceActor in
+                            let handler = PseudoCommandHandler()
+                            await handler.rejectSuggestions()
+                        }
+                    },
+                    onAcceptSuggestionTapped: {
+                        Task { @ServiceActor in
+                            let handler = PseudoCommandHandler()
+                            await handler.acceptSuggestion()
+                        }
+                    }
+                )
+            }
+        }
+        return nil
+    }
+
+    func chatForFile(at url: URL) async -> ChatProvider? {
+        for workspace in await workspaces.values {
+            if let filespace = await workspace.filespaces[url],
+               let service = await filespace.chatService
+            {
+                return .init(
+                    service: service,
+                    fileURL: url,
+                    onCloseChat: { [weak filespace] in
+                        Task { @ServiceActor [weak filespace] in
+                            filespace?.chatService = nil
+                        }
+                    }
+                )
+            }
+        }
+        return nil
+    }
+
+    func chatServiceForFile(at url: URL) async -> ChatService? {
+        for workspace in await workspaces.values {
+            if let filespace = await workspace.filespaces[url] {
+                return await filespace.chatService
+            }
+        }
+        return nil
+    }
+}