Merge branch 'feature/prompt-to-code-with-github-copilot' into develop

Author: intitni

Copilot for Xcode/SettingsView.swift

@@ -22,6 +22,8 @@ struct SettingsView: View {
         var disableSuggestionFeatureGlobally: Bool
         @AppStorage(\.suggestionFeatureEnabledProjectList)
         var suggestionFeatureEnabledProjectList: [String]
+        @AppStorage(\.promptToCodeFeatureProvider)
+        var promptToCodeFeatureProvider: PromptToCodeFeatureProvider
         init() {}
     }
 
@@ -134,6 +136,19 @@ struct SettingsView: View {
                     Text("Use accessibility API to accept suggestion in widget")
                 }
                 .toggleStyle(.switch)
+                
+                Picker(selection: $settings.promptToCodeFeatureProvider) {
+                    ForEach(PromptToCodeFeatureProvider.allCases, id: \.rawValue) {
+                        switch $0 {
+                        case .openAI:
+                            Text("OpenAI").tag($0)
+                        case .githubCopilot:
+                            Text("GitHub Copilot (Less Accurate)").tag($0)
+                        }
+                    }
+                } label: {
+                    Text("Prompt to code with")
+                }
             }
         }.buttonStyle(.copilot)
     }

Core/Sources/Preferences/Keys.swift

@@ -151,6 +151,15 @@ public struct UserDefaultPreferenceKeys {
     public var suggestionFeatureEnabledProjectList: SuggestionFeatureEnabledProjectList {
         .init()
     }
+    
+    public struct PromptToCodeFeatureProviderKey: UserDefaultPreferenceKey {
+        public let defaultValue: PromptToCodeFeatureProvider = .openAI
+        public let key = "PromptToCodeFeatureProvider"
+    }
+    
+    public var promptToCodeFeatureProvider: PromptToCodeFeatureProviderKey {
+        .init()
+    }
 
     public var disableLazyVStack: FeatureFlags.DisableLazyVStack { .init() }
     public var preCacheOnFileOpen: FeatureFlags.PreCacheOnFileOpen { .init() }

Core/Sources/Preferences/PromptToCodeFeatureProvider.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+public enum PromptToCodeFeatureProvider: Int, CaseIterable {
+    case openAI
+    case githubCopilot
+}

Core/Sources/PromptToCodeService/CopilotPromptToCodeAPI.swift

@@ -4,17 +4,85 @@ import Foundation
 import OpenAIService
 
 final class CopilotPromptToCodeAPI: PromptToCodeAPI {
+    var task: Task<Void, Never>?
+
     func stopResponding() {
-        fatalError()
+        task?.cancel()
     }
 
     func modifyCode(
         code: String,
         language: CopilotLanguage,
         indentSize: Int,
         usesTabsForIndentation: Bool,
-        requirement: String
+        requirement: String,
+        projectRootURL: URL,
+        fileURL: URL,
+        allCode: String
     ) async throws -> AsyncThrowingStream<(code: String, description: String), Error> {
-        fatalError()
+        let copilotService = CopilotSuggestionService(projectRootURL: projectRootURL)
+        let relativePath = {
+            let filePath = fileURL.path
+            let rootPath = projectRootURL.path
+            if let range = filePath.range(of: rootPath),
+               range.lowerBound == filePath.startIndex
+            {
+                let relativePath = filePath.replacingCharacters(
+                    in: filePath.startIndex..<range.upperBound,
+                    with: ""
+                )
+                return relativePath
+            }
+            return filePath
+        }()
+        
+        let comment = """
+        // update the following code, \(requirement.split(separator: "\n").joined(separator: " ")).
+        \(code.split(separator: "\n").map { "//\($0)" }.joined(separator: "\n"))
+        
+        
+        
+        // Path: \(relativePath)
+        
+        """
+        let lineCount = comment.breakLines().count
+
+        return .init { continuation in
+            self.task = Task {
+                do {
+                    let result = try await copilotService.getCompletions(
+                        fileURL: fileURL,
+                        content: comment,
+                        cursorPosition: .init(line: lineCount - 4, character: 0),
+                        tabSize: indentSize,
+                        indentSize: indentSize,
+                        usesTabsForIndentation: usesTabsForIndentation,
+                        ignoreSpaceOnlySuggestions: true
+                    )
+                    try Task.checkCancellation()
+                    guard let first = result.first else { throw CancellationError() }
+                    continuation.yield((first.text, ""))
+                    continuation.finish()
+                } catch {
+                    continuation.finish(throwing: error)
+                }
+            }
+        }
+    }
+}
+
+extension String {
+    /// Break a string into lines.
+    func breakLines() -> [String] {
+        let lines = split(separator: "\n", omittingEmptySubsequences: false)
+        var all = [String]()
+        for (index, line) in lines.enumerated() {
+            if index == lines.endIndex - 1 {
+                all.append(String(line))
+            } else {
+                all.append(String(line) + "\n")
+            }
+        }
+        return all
     }
 }

Core/Sources/PromptToCodeService/OpenAIPromptToCodeAPI.swift

@@ -17,7 +17,10 @@ final class OpenAIPromptToCodeAPI: PromptToCodeAPI {
         language: CopilotLanguage,
         indentSize: Int,
         usesTabsForIndentation: Bool,
-        requirement: String
+        requirement: String,
+        projectRootURL: URL,
+        fileURL: URL,
+        allCode: String
     ) async throws -> AsyncThrowingStream<(code: String, description: String), Error> {
         let userPreferredLanguage = UserDefaults.shared.value(for: \.chatGPTLanguage)
         let textLanguage = userPreferredLanguage.isEmpty ? "" : "in \(userPreferredLanguage)"