feat: add GitHub Copilot support with rewritten inline suggestion architecture

CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- AI provider registry for extensible provider management
+- GitHub Copilot as an AI chat provider option (LSP transport pending)
 - In-app feedback form for bug reports and feature requests via Help > Report an Issue
 - Per-connection "Local only" option to exclude individual connections from iCloud sync
 - Filter operator picker shows SQL symbols alongside names for quick visual recognition

TablePro/Core/AI/AIProviderFactory.swift

@@ -45,6 +45,8 @@ enum AIProviderFactory {
                     apiKey: apiKey ?? "",
                     maxOutputTokens: config.maxOutputTokens ?? 8_192
                 )
+            case .copilot:
+                provider = CopilotChatProvider()
             case .openAI, .openRouter, .ollama, .custom:
                 provider = OpenAICompatibleProvider(
                     endpoint: config.endpoint,
@@ -70,18 +72,46 @@ enum AIProviderFactory {
         for feature: AIFeature,
         settings: AISettings
     ) -> (AIProviderConfig, String?)? {
-        if let route = settings.featureRouting[feature.rawValue],
-           let config = settings.providers.first(where: { $0.id == route.providerID && $0.isEnabled }) {
+        // Check feature routing: explicit provider or Copilot
+        if let route = settings.featureRouting[feature.rawValue] {
+            // Routed to Copilot
+            if route.providerID == AIProviderConfig.copilotProviderID, settings.copilotChatEnabled {
+                let config = AIProviderConfig(
+                    id: AIProviderConfig.copilotProviderID,
+                    name: "GitHub Copilot",
+                    type: .copilot,
+                    model: route.model,
+                    endpoint: ""
+                )
+                return (config, nil)
+            }
+
+            // Routed to a regular provider
+            if let config = settings.providers.first(where: { $0.id == route.providerID && $0.isEnabled }) {
+                let apiKey = AIKeyStorage.shared.loadAPIKey(for: config.id)
+                return (config, apiKey)
+            }
+        }
+
+        // Fallback: first enabled provider
+        if let config = settings.providers.first(where: { $0.isEnabled }) {
             let apiKey = AIKeyStorage.shared.loadAPIKey(for: config.id)
             return (config, apiKey)
         }
 
-        guard let config = settings.providers.first(where: { $0.isEnabled }) else {
-            return nil
+        // Last resort: if copilotChatEnabled and no other providers, use Copilot
+        if settings.copilotChatEnabled {
+            let config = AIProviderConfig(
+                id: AIProviderConfig.copilotProviderID,
+                name: "GitHub Copilot",
+                type: .copilot,
+                model: "",
+                endpoint: ""
+            )
+            return (config, nil)
         }
 
-        let apiKey = AIKeyStorage.shared.loadAPIKey(for: config.id)
-        return (config, apiKey)
+        return nil
     }
 
     static func resolveModel(

TablePro/Core/AI/Copilot/CopilotAuthManager.swift

@@ -0,0 +1,82 @@
+//
+//  CopilotAuthManager.swift
+//  TablePro
+//
+
+import AppKit
+import Foundation
+import os
+
+@MainActor
+final class CopilotAuthManager {
+    private static let logger = Logger(subsystem: "com.TablePro", category: "CopilotAuth")
+
+    struct SignInResult {
+        let userCode: String
+        let verificationURI: String
+    }
+
+    private struct SignInInitiateResponse: Decodable {
+        let status: String
+        let userCode: String
+        let verificationUri: String
+    }
+
+    private struct SignInConfirmResponse: Decodable {
+        let status: String
+        let user: String
+    }
+
+    func initiateSignIn(transport: LSPTransport) async throws -> SignInResult {
+        let data: Data = try await transport.sendRequest(
+            method: "signInInitiate",
+            params: EmptyLSPParams()
+        )
+        let response = try JSONDecoder().decode(SignInInitiateResponse.self, from: data)
+
+        NSPasteboard.general.clearContents()
+        NSPasteboard.general.setString(response.userCode, forType: .string)
+
+        if let url = URL(string: response.verificationUri) {
+            NSWorkspace.shared.open(url)
+        }
+
+        Self.logger.info("Sign-in initiated, user code copied to clipboard")
+        return SignInResult(userCode: response.userCode, verificationURI: response.verificationUri)
+    }
+
+    func completeSignIn(transport: LSPTransport) async throws -> String {
+        let maxAttempts = 60
+        let pollInterval: Duration = .seconds(2)
+
+        for _ in 0..<maxAttempts {
+            try Task.checkCancellation()
+            let data: Data = try await transport.sendRequest(
+                method: "signInConfirm",
+                params: EmptyLSPParams()
+            )
+            let response = try JSONDecoder().decode(SignInConfirmResponse.self, from: data)
+
+            if response.status == "OK" || response.status == "AlreadySignedIn" {
+                Self.logger.info("Sign-in completed for user: \(response.user)")
+                return response.user
+            }
+
+            try await Task.sleep(for: pollInterval)
+        }
+
+        throw CopilotError.authenticationFailed(String(localized: "Sign-in timed out"))
+    }
+
+    func signOut(transport: LSPTransport) async {
+        do {
+            let _: Data = try await transport.sendRequest(
+                method: "signOut",
+                params: EmptyLSPParams()
+            )
+            Self.logger.info("Signed out of GitHub Copilot")
+        } catch {
+            Self.logger.error("Sign-out failed: \(error.localizedDescription)")
+        }
+    }
+}

TablePro/Core/AI/Copilot/CopilotBinaryManager.swift

@@ -0,0 +1,155 @@
+//
+//  CopilotBinaryManager.swift
+//  TablePro
+//
+
+import CommonCrypto
+import Foundation
+import os
+
+actor CopilotBinaryManager {
+    private static let logger = Logger(subsystem: "com.TablePro", category: "CopilotBinary")
+    static let shared = CopilotBinaryManager()
+
+    private let baseDirectory: URL
+    private var downloadTask: Task<Void, Error>?
+
+    private init() {
+        let appSupport = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
+            ?? FileManager.default.temporaryDirectory
+        baseDirectory = appSupport.appendingPathComponent("TablePro/copilot-language-server", isDirectory: true)
+    }
+
+    func ensureBinary() async throws -> String {
+        let path = binaryExecutablePath
+        if FileManager.default.isExecutableFile(atPath: path) {
+            return path
+        }
+
+        if let existing = downloadTask {
+            try await existing.value
+        } else {
+            let task = Task { try await downloadBinary() }
+            downloadTask = task
+            do {
+                try await task.value
+                downloadTask = nil
+            } catch {
+                downloadTask = nil
+                throw error
+            }
+        }
+
+        guard FileManager.default.isExecutableFile(atPath: path) else {
+            throw CopilotError.binaryNotFound
+        }
+        return path
+    }
+
+    private func downloadBinary() async throws {
+        try FileManager.default.createDirectory(at: baseDirectory, withIntermediateDirectories: true)
+
+        let platform = self.platform
+        let optionalDep = "@github/copilot-language-server-\(platform)"
+
+        guard let registryURL = URL(string: "https://registry.npmjs.org/\(optionalDep)/latest") else {
+            throw CopilotError.binaryNotFound
+        }
+        let (data, _) = try await URLSession.shared.data(from: registryURL)
+
+        guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let dist = json["dist"] as? [String: Any],
+              let tarballURLString = dist["tarball"] as? String,
+              let tarballURL = URL(string: tarballURLString) else {
+            throw CopilotError.binaryNotFound
+        }
+
+        let (tarballData, _) = try await URLSession.shared.data(from: tarballURL)
+
+        if let expectedShasum = dist["shasum"] as? String {
+            let actualHash = tarballData.sha1HexString()
+            if actualHash != expectedShasum {
+                Self.logger.error("Binary checksum mismatch: expected \(expectedShasum), got \(actualHash)")
+                throw CopilotError.binaryNotFound
+            }
+        }
+
+        let tempTar = baseDirectory.appendingPathComponent("download.tar.gz")
+        try tarballData.write(to: tempTar)
+
+        let process = Process()
+        process.executableURL = URL(fileURLWithPath: "/usr/bin/tar")
+        process.arguments = ["xzf", tempTar.path, "-C", baseDirectory.path, "--strip-components=1", "package/copilot-language-server"]
+
+        try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+            process.terminationHandler = { proc in
+                if proc.terminationStatus == 0 {
+                    continuation.resume()
+                } else {
+                    continuation.resume(throwing: CopilotError.binaryNotFound)
+                }
+            }
+            do {
+                try process.run()
+            } catch {
+                continuation.resume(throwing: error)
+            }
+        }
+
+        try? FileManager.default.removeItem(at: tempTar)
+
+        // Verify extraction; try to find binary if not at expected path
+        if !FileManager.default.fileExists(atPath: binaryExecutablePath) {
+            let enumerator = FileManager.default.enumerator(at: baseDirectory, includingPropertiesForKeys: nil)
+            while let fileURL = enumerator?.nextObject() as? URL {
+                if fileURL.lastPathComponent == "copilot-language-server" {
+                    let foundPath = fileURL.path
+                    if foundPath != binaryExecutablePath {
+                        try FileManager.default.moveItem(atPath: foundPath, toPath: binaryExecutablePath)
+                        Self.logger.info("Moved binary from \(foundPath) to expected location")
+                    }
+                    break
+                }
+            }
+        }
+
+        try FileManager.default.setAttributes(
+            [.posixPermissions: 0o755],
+            ofItemAtPath: binaryExecutablePath
+        )
+
+        // Store version for future reference
+        if let version = json["version"] as? String {
+            let versionFile = baseDirectory.appendingPathComponent("version.txt")
+            try? version.write(to: versionFile, atomically: true, encoding: .utf8)
+            Self.logger.info("Installed Copilot language server version \(version)")
+        }
+
+        Self.logger.info("Downloaded Copilot language server binary")
+    }
+
+    func installedVersion() -> String? {
+        let versionFile = baseDirectory.appendingPathComponent("version.txt")
+        return try? String(contentsOf: versionFile, encoding: .utf8).trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    private var binaryExecutablePath: String {
+        baseDirectory.appendingPathComponent("copilot-language-server").path
+    }
+
+    private var platform: String {
+        #if arch(arm64)
+        return "darwin-arm64"
+        #else
+        return "darwin-x64"
+        #endif
+    }
+}
+
+private extension Data {
+    func sha1HexString() -> String {
+        var digest = [UInt8](repeating: 0, count: Int(CC_SHA1_DIGEST_LENGTH))
+        withUnsafeBytes { CC_SHA1($0.baseAddress, CC_LONG(count), &digest) }
+        return digest.map { String(format: "%02x", $0) }.joined()
+    }
+}

TablePro/Core/AI/Copilot/CopilotChatProvider.swift

@@ -0,0 +1,63 @@
+//
+//  CopilotChatProvider.swift
+//  TablePro
+//
+//  AIProvider implementation for GitHub Copilot Chat.
+//  Uses the Copilot LSP conversation protocol for streaming chat completions.
+//  Requires an authenticated CopilotService with a running LSP server.
+//
+
+import Foundation
+import os
+
+/// AI provider that routes chat requests through the GitHub Copilot LSP server
+final class CopilotChatProvider: AIProvider {
+    private static let logger = Logger(subsystem: "com.TablePro", category: "CopilotChatProvider")
+
+    // MARK: - AIProvider
+
+    func streamChat(
+        messages: [AIChatMessage],
+        model: String,
+        systemPrompt: String?
+    ) -> AsyncThrowingStream<AIStreamEvent, Error> {
+        AsyncThrowingStream { continuation in
+            let task = Task { @MainActor in
+                do {
+                    guard CopilotService.shared.isAuthenticated else {
+                        throw CopilotError.serverNotRunning
+                    }
+
+                    // LSP transport not yet available. Once the Copilot LSP client ships,
+                    // this will use conversation/create + conversation/turn to stream responses.
+                    throw CopilotError.serverNotRunning
+                } catch {
+                    continuation.finish(throwing: error)
+                }
+            }
+
+            continuation.onTermination = { _ in
+                task.cancel()
+            }
+        }
+    }
+
+    func fetchAvailableModels() async throws -> [String] {
+        guard await CopilotService.shared.isAuthenticated else {
+            throw CopilotError.serverNotRunning
+        }
+
+        // Default models available through Copilot Chat.
+        // Once LSP transport ships, this will query copilot/models.
+        return [
+            "gpt-4o",
+            "gpt-4o-mini",
+            "claude-3.5-sonnet",
+            "o3-mini"
+        ]
+    }
+
+    func testConnection() async throws -> Bool {
+        await CopilotService.shared.isAuthenticated
+    }
+}