CopilotForXcode/Core/Sources/SuggestionService/SuggestionService.swift at main · deepfork/CopilotForXcode · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
import Foundation
import Preferences
import SuggestionModel
import SuggestionProvider
import UserDefaultsObserver

#if canImport(ProExtension)
import ProExtension
#endif

public protocol SuggestionServiceType: SuggestionServiceProvider {}

public actor SuggestionService: SuggestionServiceType {
    var middlewares: [SuggestionServiceMiddleware] {
        SuggestionServiceMiddlewareContainer.middlewares
    }

    let projectRootURL: URL
    let onServiceLaunched: (SuggestionServiceProvider) -> Void
    let providerChangeObserver = UserDefaultsObserver(
        object: UserDefaults.shared,
        forKeyPaths: [UserDefaultPreferenceKeys().suggestionFeatureProvider.key],
        context: nil
    )

    lazy var suggestionProvider: SuggestionServiceProvider = buildService()

    var serviceType: SuggestionFeatureProvider {
        UserDefaults.shared.value(for: \.suggestionFeatureProvider)
    }

    public init(
        projectRootURL: URL,
        onServiceLaunched: @escaping (SuggestionServiceProvider) -> Void
    ) {
        self.projectRootURL = projectRootURL
        self.onServiceLaunched = onServiceLaunched

        providerChangeObserver.onChange = { [weak self] in
            Task { [weak self] in
                guard let self else { return }
                await rebuildService()
            }
        }
    }

    func buildService() -> SuggestionServiceProvider {
        #if canImport(ProExtension)
        if let provider = ProExtension.suggestionProviderFactory(serviceType) {
            return provider
        }
        #endif

        switch serviceType {
        case .builtIn(.codeium):
            return CodeiumSuggestionProvider(
                projectRootURL: projectRootURL,
                onServiceLaunched: onServiceLaunched
            )
        case .builtIn(.gitHubCopilot), .extension:
            return GitHubCopilotSuggestionProvider(
                projectRootURL: projectRootURL,
                onServiceLaunched: onServiceLaunched
            )
        }
    }

    func rebuildService() {
        suggestionProvider = buildService()
    }
}

public extension SuggestionService {
    func getSuggestions(
        _ request: SuggestionRequest
    ) async throws -> [SuggestionModel.CodeSuggestion] {
        var getSuggestion = suggestionProvider.getSuggestions

        for middleware in middlewares.reversed() {
            getSuggestion = { [getSuggestion] request in
                try await middleware.getSuggestion(request, next: getSuggestion)
            }
        }

        return try await getSuggestion(request)
    }

    func notifyAccepted(_ suggestion: SuggestionModel.CodeSuggestion) async {
        await suggestionProvider.notifyAccepted(suggestion)
    }

    func notifyRejected(_ suggestions: [SuggestionModel.CodeSuggestion]) async {
        await suggestionProvider.notifyRejected(suggestions)
    }

    func notifyOpenTextDocument(fileURL: URL, content: String) async throws {
        try await suggestionProvider.notifyOpenTextDocument(fileURL: fileURL, content: content)
    }

    func notifyChangeTextDocument(fileURL: URL, content: String) async throws {
        try await suggestionProvider.notifyChangeTextDocument(fileURL: fileURL, content: content)
    }

    func notifyCloseTextDocument(fileURL: URL) async throws {
        try await suggestionProvider.notifyCloseTextDocument(fileURL: fileURL)
    }

    func notifySaveTextDocument(fileURL: URL) async throws {
        try await suggestionProvider.notifySaveTextDocument(fileURL: fileURL)
    }

    func cancelRequest() async {
        await suggestionProvider.cancelRequest()
    }

    func terminate() async {
        await suggestionProvider.terminate()
    }
}