Merge branch 'release/0.10.0'

Author: intitni

Copilot for Xcode.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -5,6 +5,7 @@ import Preferences
 import SwiftUI
 
 final class OpenAIViewSettings: ObservableObject {
+    static let availableLocalizedLocales = Locale.availableLocalizedLocales
     @AppStorage(\.openAIAPIKey) var openAIAPIKey: String
     @AppStorage(\.chatGPTModel) var chatGPTModel: String
     @AppStorage(\.chatGPTEndpoint) var chatGPTEndpoint: String
@@ -30,68 +31,124 @@ struct OpenAIView: View {
 
                 Form {
                     HStack {
-                        Text("OpenAI API Key")
                         TextField(text: $settings.openAIAPIKey, prompt: Text("sk-*")) {
-                            EmptyView()
-                        }.textFieldStyle(.copilot)
+                            Text("OpenAI API Key")
+                        }.textFieldStyle(.roundedBorder)
                         Button(action: {
                             openURL(apiKeyURL)
                         }) {
                             Image(systemName: "questionmark.circle.fill")
-                        }
-                        .buttonStyle(.plain)
+                        }.buttonStyle(.plain)
                     }
 
                     HStack {
-                        Text("ChatGPT Model")
-                        TextField(text: $settings.chatGPTModel, prompt: Text("gpt-3.5-turbo")) {
-                            EmptyView()
-                        }.textFieldStyle(.copilot)
-
+                        Picker(selection: $settings.chatGPTModel) {
+                            if !settings.chatGPTModel.isEmpty,
+                               ChatGPTModel(rawValue: settings.chatGPTModel) == nil
+                            {
+                                Text(settings.chatGPTModel).tag(settings.chatGPTModel)
+                            }
+                            ForEach(ChatGPTModel.allCases, id: \.self) { model in
+                                Text(model.rawValue).tag(model.rawValue)
+                            }
+                        } label: {
+                            Text("ChatGPT Model")
+                        }.pickerStyle(.menu)
                         Button(action: {
                             openURL(modelURL)
                         }) {
                             Image(systemName: "questionmark.circle.fill")
+                        }.buttonStyle(.plain)
+                    }
+                    .onChange(of: settings.chatGPTModel) { newValue in
+                        if let model = ChatGPTModel(rawValue: newValue) {
+                            settings.chatGPTEndpoint = model.endpoint
                         }
-                        .buttonStyle(.plain)
                     }
 
-                    HStack {
-                        Text("ChatGPT Endpoint")
-                        TextField(
-                            text: $settings.chatGPTEndpoint,
-                            prompt: Text("https://api.openai.com/v1/chat/completions")
-                        ) {
-                            EmptyView()
-                        }.textFieldStyle(.copilot)
-                    }
-                    
-                    HStack {
-                        Text("Reply in Language")
-                        TextField(
-                            text: $settings.chatGPTLanguage,
-                            prompt: Text("e.g. English. Leave it blank to let the bot decide.")
-                        ) {
-                            EmptyView()
-                        }.textFieldStyle(.copilot)
+                    TextField(
+                        text: $settings.chatGPTEndpoint,
+                        prompt: Text("https://api.openai.com/v1/chat/completions")
+                    ) {
+                        Text("ChatGPT Server")
+                    }.textFieldStyle(.roundedBorder)
+
+                    if #available(macOS 13.0, *) {
+                        LabeledContent("Reply in Language") {
+                            languagePicker
+                        }
+                    } else {
+                        HStack {
+                            Text("Reply in Language")
+                            languagePicker
+                        }
                     }
-                    
-                    HStack {
-                        Text("Max Token")
-                        TextField(
-                            text: .init(get: {
-                                String(settings.chatGPTMaxToken)
-                            }, set: { newValue in
-                                settings.chatGPTMaxToken = Int(newValue) ?? 0
-                            })
-                        ) {
-                            EmptyView()
-                        }.textFieldStyle(.copilot)
+
+                    if let model = ChatGPTModel(rawValue: settings.chatGPTModel) {
+                        let binding = Binding(
+                            get: { String(settings.chatGPTMaxToken) },
+                            set: {
+                                if let selectionMaxToken = Int($0) {
+                                    settings.chatGPTMaxToken = model
+                                        .maxToken < selectionMaxToken ? model
+                                        .maxToken : selectionMaxToken
+                                } else {
+                                    settings.chatGPTMaxToken = 0
+                                }
+                            }
+                        )
+                        HStack {
+                            Stepper(
+                                value: $settings.chatGPTMaxToken,
+                                in: 0...model.maxToken,
+                                step: 1
+                            ) {
+                                Text("Max Token")
+                            }
+                            TextField(text: binding) {
+                                EmptyView()
+                            }
+                            .labelsHidden()
+                            .textFieldStyle(.roundedBorder)
+                        }
                     }
                 }
             }
         }
     }
+    
+    var languagePicker: some View {
+        Menu {
+            if !settings.chatGPTLanguage.isEmpty,
+               !OpenAIViewSettings.availableLocalizedLocales
+                .contains(settings.chatGPTLanguage)
+            {
+                Button(
+                    settings.chatGPTLanguage,
+                    action: { self.settings.chatGPTLanguage = settings.chatGPTLanguage }
+                )
+            }
+            Button(
+                "Auto-detected by ChatGPT",
+                action: { self.settings.chatGPTLanguage = "" }
+            )
+            ForEach(
+                OpenAIViewSettings.availableLocalizedLocales,
+                id: \.self
+            ) { localizedLocales in
+                Button(
+                    localizedLocales,
+                    action: { self.settings.chatGPTLanguage = localizedLocales }
+                )
+            }
+        } label: {
+            Text(
+                settings.chatGPTLanguage.isEmpty
+                ? "Auto-detected by ChatGPT"
+                : settings.chatGPTLanguage
+            )
+        }
+    }
 }
 
 struct OpenAIView_Previews: PreviewProvider {

Copilot for Xcode/OpenAIView.swift

@@ -15,6 +15,8 @@ final class Settings: ObservableObject {
     var suggestionWidgetPositionMode: SuggestionWidgetPositionMode
     @AppStorage(\.widgetColorScheme)
     var widgetColorScheme: WidgetColorScheme
+    @AppStorage(\.acceptSuggestionWithAccessibilityAPI)
+    var acceptSuggestionWithAccessibilityAPI: Bool
     init() {}
 }
 
@@ -107,6 +109,11 @@ struct SettingsView: View {
                             .fill(Color.white.opacity(0.2))
                     )
                 }
+                
+                Toggle(isOn: $settings.acceptSuggestionWithAccessibilityAPI) {
+                    Text("Use accessibility API to accept suggestion in widget")
+                }
+                .toggleStyle(.switch)
             }
         }.buttonStyle(.copilot)
     }

Copilot for Xcode/SettingsView.swift

@@ -37,8 +37,8 @@ let package = Package(
         .package(url: "https://github.com/raspu/Highlightr", from: "2.1.0"),
         .package(url: "https://github.com/JohnSundell/Splash", from: "0.1.0"),
         .package(url: "https://github.com/nmdias/FeedKit", from: "9.1.2"),
-        .package(url: "https://github.com/gonzalezreal/swift-markdown-ui", from: "2.0.0"),
-        .package(url: "https://github.com/sparkle-project/Sparkle", from: "2.0.0"),
+        .package(url: "https://github.com/intitni/swift-markdown-ui", branch: "main"),
+        .package(url: "https://github.com/sparkle-project/Sparkle", from: "2.0.0"), 
     ],
     targets: [
         .target(name: "CGEventObserver"),
@@ -86,6 +86,7 @@ let package = Package(
                 "SuggestionWidget",
                 "AXExtension",
                 "Logger",
+                "ChatService",
                 .product(name: "AsyncAlgorithms", package: "swift-async-algorithms"),
             ]
         ),
@@ -147,5 +148,8 @@ let package = Package(
             dependencies: ["OpenAIService"]
         ),
         .target(name: "Preferences"),
+        .target(name: "ChatPlugins", dependencies: ["OpenAIService", "Environment", "Terminal"]),
+        .target(name: "Terminal"),
+        .target(name: "ChatService", dependencies: ["OpenAIService", "ChatPlugins", "Environment"]),
     ]
 )

Core/Package.swift

@@ -2,14 +2,16 @@ import AppKit
 
 public final class ActiveApplicationMonitor {
     static let shared = ActiveApplicationMonitor()
-    var latestXcode: NSRunningApplication?
+    var latestXcode: NSRunningApplication? = NSWorkspace.shared.runningApplications
+        .first(where: \.isXcode)
     var activeApplication = NSWorkspace.shared.runningApplications.first(where: \.isActive) {
         didSet {
             if activeApplication?.isXcode ?? false {
                 latestXcode = activeApplication
             }
         }
     }
+
     private var continuations: [UUID: AsyncStream<NSRunningApplication?>.Continuation] = [:]
 
     private init() {
@@ -40,7 +42,7 @@ public final class ActiveApplicationMonitor {
         }
         return nil
     }
-    
+
     public static var latestXcode: NSRunningApplication? { shared.latestXcode }
 
     public static func createStream() -> AsyncStream<NSRunningApplication?> {
@@ -72,7 +74,6 @@ public final class ActiveApplicationMonitor {
     }
 }
 
-extension NSRunningApplication {
-    public var isXcode: Bool { bundleIdentifier == "com.apple.dt.Xcode" }
+public extension NSRunningApplication {
+    var isXcode: Bool { bundleIdentifier == "com.apple.dt.Xcode" }
 }
-

Core/Sources/ActiveApplicationMonitor/ActiveApplicationMonitor.swift

@@ -0,0 +1,20 @@
+import Foundation
+import OpenAIService
+
+public protocol ChatPlugin {
+    /// Should be [a-zA-Z0-9]+
+    static var command: String { get }
+    var name: String { get }
+
+    init(inside chatGPTService: ChatGPTServiceType, delegate: ChatPluginDelegate)
+    func send(content: String) async
+    func cancel() async
+    func stopResponding() async
+}
+
+public protocol ChatPluginDelegate: AnyObject {
+    func pluginDidStart(_ plugin: ChatPlugin)
+    func pluginDidEnd(_ plugin: ChatPlugin)
+    func pluginDidStartResponding(_ plugin: ChatPlugin)
+    func pluginDidEndResponding(_ plugin: ChatPlugin)
+}

Core/Sources/ChatPlugins/ChatPlugin.swift

@@ -0,0 +1,104 @@
+import Environment
+import Foundation
+import OpenAIService
+import Terminal
+
+public actor TerminalChatPlugin: ChatPlugin {
+    public static var command: String { "run" }
+    public nonisolated var name: String { "Terminal" }
+
+    let chatGPTService: ChatGPTServiceType
+    var terminal: TerminalType = Terminal()
+    var isCancelled = false
+    weak var delegate: ChatPluginDelegate?
+
+    public init(inside chatGPTService: ChatGPTServiceType, delegate: ChatPluginDelegate) {
+        self.chatGPTService = chatGPTService
+        self.delegate = delegate
+    }
+
+    public func send(content: String) async {
+        delegate?.pluginDidStart(self)
+        delegate?.pluginDidStartResponding(self)
+
+        let id = "\(Self.command)-\(UUID().uuidString)"
+        var message = ChatMessage(id: id, role: .assistant, content: "")
+        var outputContent = "" {
+            didSet {
+                message.content = """
+                ```
+                \(outputContent)
+                ```
+                """
+            }
+        }
+
+        do {
+            let fileURL = try await Environment.fetchCurrentFileURL()
+            let projectURL = try await Environment.fetchCurrentProjectRootURL(fileURL)
+
+            await chatGPTService.mutateHistory { history in
+                history.append(.init(role: .user, content: "Run command: \(content)"))
+            }
+
+            if isCancelled { throw CancellationError() }
+
+            let output = terminal.streamCommand(
+                "/bin/bash",
+                arguments: ["-c", content],
+                currentDirectoryPath: projectURL?.path ?? fileURL.path,
+                environment: [
+                    "PROJECT_ROOT": projectURL?.path ?? fileURL.path,
+                    "FILE_PATH": fileURL.path,
+                ]
+            )
+
+            for try await content in output {
+                if isCancelled { throw CancellationError() }
+                await chatGPTService.mutateHistory { history in
+                    if history.last?.id == id {
+                        history.removeLast()
+                    }
+                    outputContent += content
+                    history.append(message)
+                }
+            }
+            outputContent += "\n[finished]"
+            await chatGPTService.mutateHistory { history in
+                if history.last?.id == id {
+                    history.removeLast()
+                }
+                history.append(message)
+            }
+        } catch let error as Terminal.TerminationError {
+            outputContent += "\n[error: \(error.status)]"
+            await chatGPTService.mutateHistory { history in
+                if history.last?.id == id {
+                    history.removeLast()
+                }
+                history.append(message)
+            }
+        } catch {
+            outputContent += "\n[error: \(error.localizedDescription)]"
+            await chatGPTService.mutateHistory { history in
+                if history.last?.id == id {
+                    history.removeLast()
+                }
+                history.append(message)
+            }
+        }
+
+        delegate?.pluginDidEndResponding(self)
+        delegate?.pluginDidEnd(self)
+    }
+
+    public func cancel() async {
+        isCancelled = true
+        await terminal.terminate()
+    }
+    
+    public func stopResponding() async {
+        isCancelled = true
+        await terminal.terminate()
+    }
+}