Merge branch 'feature/window-base-suggestion-presenter' into develop

Author: intitni

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

@@ -9,6 +9,8 @@ struct SettingsView: View {
     var realtimeSuggestionToggle: Bool = false
     @AppStorage(SettingsKey.realtimeSuggestionDebounce, store: .shared)
     var realtimeSuggestionDebounce: Double = 0.7
+    @AppStorage(SettingsKey.suggestionPresentationMode, store: .shared)
+    var suggestionPresentationModeRawValue: Int = 0
     @State var editingRealtimeSuggestionDebounce: Double = UserDefaults.shared
         .value(forKey: SettingsKey.realtimeSuggestionDebounce) as? Double ?? 0.7
 
@@ -19,6 +21,20 @@ struct SettingsView: View {
                     Text("Quit service when Xcode and host app are terminated")
                 }
                 .toggleStyle(.switch)
+
+                Picker(selection: $suggestionPresentationModeRawValue) {
+                    ForEach(PresentationMode.allCases, id: \.rawValue) {
+                        switch $0 {
+                        case .comment:
+                            Text("Comment")
+                        case .floatingWidget:
+                            Text("Floating Widget")
+                        }
+                    }
+                } label: {
+                    Text("Present suggestions in")
+                }
+                
                 Toggle(isOn: $realtimeSuggestionToggle) {
                     Text("Real-time suggestion")
                 }

Copilot for Xcode/SettingsView.swift

@@ -18,6 +18,7 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/ChimeHQ/LanguageClient", from: "0.3.1"),
+        .package(url: "https://github.com/apple/swift-async-algorithms", from: "0.1.0"),
     ],
     targets: [
         .target(name: "CGEventObserver"),
@@ -51,17 +52,50 @@ let package = Package(
         ),
         .target(
             name: "Service",
-            dependencies: ["CopilotModel", "CopilotService", "XPCShared", "CGEventObserver"]
+            dependencies: [
+                "CopilotModel",
+                "CopilotService",
+                "XPCShared",
+                "CGEventObserver",
+                "DisplayLink",
+                "ActiveApplicationMonitor",
+                "AXNotificationStream",
+                "Environment",
+                "SuggestionWidget",
+                .product(name: "AsyncAlgorithms", package: "swift-async-algorithms"),
+            ]
         ),
         .target(
             name: "XPCShared",
             dependencies: ["CopilotModel"]
         ),
         .testTarget(
             name: "ServiceTests",
-            dependencies: ["Service", "Client", "CopilotService", "SuggestionInjector", "XPCShared"]
+            dependencies: [
+                "Service",
+                "Client",
+                "CopilotService",
+                "SuggestionInjector",
+                "XPCShared",
+                "Environment",
+            ]
         ),
         .target(name: "FileChangeChecker"),
         .target(name: "LaunchAgentManager"),
+        .target(name: "DisplayLink"),
+        .target(name: "ActiveApplicationMonitor"),
+        .target(name: "AXNotificationStream"),
+        .target(
+            name: "Environment",
+            dependencies: ["ActiveApplicationMonitor", "CopilotService"]
+        ),
+        .target(
+            name: "SuggestionWidget",
+            dependencies: [
+                "ActiveApplicationMonitor",
+                "AXNotificationStream",
+                "Environment",
+            ]
+        ),
     ]
 )

Core/Package.swift

@@ -0,0 +1,76 @@
+import AppKit
+import ApplicationServices
+import Foundation
+
+public final class AXNotificationStream: AsyncSequence {
+    public typealias Stream = AsyncStream<Element>
+    public typealias Continuation = Stream.Continuation
+    public typealias AsyncIterator = Stream.AsyncIterator
+    public typealias Element = (name: String, info: CFDictionary)
+
+    private var continuation: Continuation
+    private let stream: Stream
+
+    public func makeAsyncIterator() -> Stream.AsyncIterator {
+        stream.makeAsyncIterator()
+    }
+
+    deinit {
+        continuation.finish()
+    }
+
+    public init(
+        app: NSRunningApplication,
+        element: AXUIElement? = nil,
+        notificationNames: String...
+    ) {
+        var cont: Continuation!
+        stream = Stream { continuation in
+            cont = continuation
+        }
+        continuation = cont
+        var observer: AXObserver?
+
+        func callback(
+            observer: AXObserver,
+            element: AXUIElement,
+            notificationName: CFString,
+            userInfo: CFDictionary,
+            pointer: UnsafeMutableRawPointer?
+        ) {
+            guard let pointer = pointer?.assumingMemoryBound(to: Continuation.self)
+            else { return }
+            pointer.pointee.yield((notificationName as String, userInfo))
+        }
+
+        _ = AXObserverCreateWithInfoCallback(
+            app.processIdentifier,
+            callback,
+            &observer
+        )
+        guard let observer else {
+            continuation.finish()
+            return
+        }
+
+        let observingElement = element ?? AXUIElementCreateApplication(app.processIdentifier)
+        continuation.onTermination = { @Sendable _ in
+            for name in notificationNames {
+                AXObserverRemoveNotification(observer, observingElement, name as CFString)
+            }
+            CFRunLoopRemoveSource(
+                CFRunLoopGetMain(),
+                AXObserverGetRunLoopSource(observer),
+                .commonModes
+            )
+        }
+        for name in notificationNames {
+            AXObserverAddNotification(observer, observingElement, name as CFString, &continuation)
+        }
+        CFRunLoopAddSource(
+            CFRunLoopGetMain(),
+            AXObserverGetRunLoopSource(observer),
+            .commonModes
+        )
+    }
+}

Core/Sources/AXNotificationStream/AXNotificationStream.swift

@@ -0,0 +1,64 @@
+import AppKit
+
+public final class ActiveApplicationMonitor {
+    static let shared = ActiveApplicationMonitor()
+    var activeApplication = NSWorkspace.shared.runningApplications.first(where: \.isActive)
+    private var continuations: [UUID: AsyncStream<NSRunningApplication?>.Continuation] = [:]
+
+    private init() {
+        Task {
+            let sequence = NSWorkspace.shared.notificationCenter
+                .notifications(named: NSWorkspace.didActivateApplicationNotification)
+            for await notification in sequence {
+                guard let app = notification
+                    .userInfo?[NSWorkspace.applicationUserInfoKey] as? NSRunningApplication
+                else { continue }
+                activeApplication = app
+                notifyContinuations()
+            }
+        }
+    }
+
+    deinit {
+        for continuation in continuations {
+            continuation.value.finish()
+        }
+    }
+
+    public static var activeApplication: NSRunningApplication? { shared.activeApplication }
+    
+    public static var activeXcode: NSRunningApplication? {
+        if activeApplication?.bundleIdentifier == "com.apple.dt.Xcode" {
+            return activeApplication
+        }
+        return nil
+    }
+
+    public static func createStream() -> AsyncStream<NSRunningApplication?> {
+        .init { continuation in
+            let id = UUID()
+            ActiveApplicationMonitor.shared.addContinuation(continuation, id: id)
+            continuation.onTermination = { _ in
+                ActiveApplicationMonitor.shared.removeContinuation(id: id)
+            }
+            continuation.yield(activeApplication)
+        }
+    }
+
+    func addContinuation(
+        _ continuation: AsyncStream<NSRunningApplication?>.Continuation,
+        id: UUID
+    ) {
+        continuations[id] = continuation
+    }
+
+    func removeContinuation(id: UUID) {
+        continuations[id] = nil
+    }
+
+    private func notifyContinuations() {
+        for continuation in continuations {
+            continuation.value.yield(activeApplication)
+        }
+    }
+}

Core/Sources/ActiveApplicationMonitor/ActiveApplicationMonitor.swift

@@ -0,0 +1,63 @@
+import Foundation
+import QuartzCore
+
+public actor DisplayLink {
+    private var displayLink: CVDisplayLink!
+    private static var _shared = DisplayLink()
+    static var shared: DisplayLink? {
+        if let _shared { return _shared }
+        _shared = DisplayLink()
+        return _shared
+    }
+    private var continuations: [UUID: AsyncStream<Void>.Continuation] = [:]
+
+    public static func createStream() -> AsyncStream<Void> {
+        .init { continuation in
+            Task {
+                let id = UUID()
+                await DisplayLink.shared?.addContinuation(continuation, id: id)
+                continuation.onTermination = { _ in
+                    Task {
+                        await DisplayLink.shared?.removeContinuation(id: id)
+                    }
+                }
+            }
+        }
+    }
+
+    private init?() {
+        _ = CVDisplayLinkCreateWithCGDisplay(CGMainDisplayID(), &displayLink)
+        guard displayLink != nil else { return nil }
+        CVDisplayLinkSetOutputHandler(displayLink) { [weak self] _, _, _, _, _ in
+            guard let self else { return kCVReturnSuccess }
+            Task { await self.notifyContinuations() }
+            return kCVReturnSuccess
+        }
+    }
+
+    deinit {
+        for continuation in continuations {
+            continuation.value.finish()
+        }
+    }
+
+    func addContinuation(_ continuation: AsyncStream<Void>.Continuation, id: UUID) {
+        continuations[id] = continuation
+        if !continuations.isEmpty {
+            CVDisplayLinkStart(displayLink)
+        }
+    }
+
+    func removeContinuation(id: UUID) {
+        continuations[id] = nil
+        if continuations.isEmpty {
+            CVDisplayLinkStop(displayLink)
+        }
+    }
+
+    private func notifyContinuations() {
+        for continuation in continuations {
+            continuation.value.yield()
+        }
+    }
+}