Pre-release 0.32.112

Author: actions-user

Core/Sources/ChatService/ChatService.swift

@@ -88,20 +88,8 @@ public final class ChatService: ChatServiceType, ObservableObject {
 
     private func subscribeToWatchedFilesHandler() {
         self.watchedFilesHandler.onWatchedFiles.sink(receiveValue: { [weak self] (request, completion) in
-            guard let self,
-                  request.params!.workspaceUri != "/",
-                  !ProjectContextSkill.isWorkspaceResolved(self.chatTabInfo.workspacePath)
-            else { return }
-            
-            ProjectContextSkill.resolveSkill(
-                request: request,
-                workspacePath: self.chatTabInfo.workspacePath,
-                completion: completion
-            )
-            
-            /// after sync complete files to CLS, start file watcher
+            guard let self, request.params!.workspaceUri != "/" else { return }
             self.startFileChangeWatcher()
-            
         }).store(in: &cancellables)
     }
 
@@ -463,20 +451,17 @@ public final class ChatService: ChatServiceType, ObservableObject {
 
         Task {
             // mark running steps to cancelled
-            if var message = await memory.history.last,
-               message.role == .assistant {
-                message.steps = message.steps.map { step in
-                    return .init(
-                        id: step.id,
-                        title: step.title,
-                        description: step.description,
-                        status: step.status == .running ? .cancelled : step.status,
-                        error: step.error
-                    )
-                }
+            await mutateHistory({ history in
+                guard !history.isEmpty,
+                      let lastIndex = history.indices.last,
+                      history[lastIndex].role == .assistant else { return }
 
-                await memory.appendMessage(message)
-            }
+                for i in 0..<history[lastIndex].steps.count {
+                    if history[lastIndex].steps[i].status == .running {
+                        history[lastIndex].steps[i].status = .cancelled
+                    }
+                }
+            })
 
             // The message of progress report could change rapidly
             // Directly upsert the last chat message of history here

Core/Sources/ConversationTab/ModelPicker.swift

@@ -31,12 +31,11 @@ extension AppState {
 extension CopilotModelManager {
     static func getAvailableChatLLMs() -> [LLMModel] {
         let LLMs = CopilotModelManager.getAvailableLLMs()
-        let availableModels = LLMs.filter(
+        return LLMs.filter(
             { $0.scopes.contains(.chatPanel) }
         ).map {
             LLMModel(modelName: $0.modelName, modelFamily: $0.modelFamily)
         }
-        return availableModels.isEmpty ? [defaultModel] : availableModels
     }
 }
 
@@ -50,6 +49,7 @@ struct ModelPicker: View {
     @State private var selectedModel = defaultModel.modelName
     @State private var isHovered = false
     @State private var isPressed = false
+    static var lastRefreshModelsTime: Date = .init(timeIntervalSince1970: 0)
 
     init() {
         self.updateCurrentModel()
@@ -66,15 +66,23 @@ struct ModelPicker: View {
     var body: some View {
         WithPerceptionTracking {
             Menu(selectedModel) {
-                ForEach(models, id: \.self) { option in
+                if models.isEmpty {
                     Button {
-                        selectedModel = option.modelName
-                        AppState.shared.setSelectedModel(option)
+                        // No action needed
                     } label: {
-                        if selectedModel == option.modelName {
-                            Text("✓ \(option.modelName)")
-                        } else {
-                            Text("    \(option.modelName)")
+                        Text("Loading...")
+                    }
+                } else {
+                    ForEach(models, id: \.self) { option in
+                        Button {
+                            selectedModel = option.modelName
+                            AppState.shared.setSelectedModel(option)
+                        } label: {
+                            if selectedModel == option.modelName {
+                                Text("✓ \(option.modelName)")
+                            } else {
+                                Text("    \(option.modelName)")
+                            }
                         }
                     }
                 }
@@ -108,6 +116,12 @@ struct ModelPicker: View {
 
     @MainActor
     func refreshModels() async {
+        let now = Date()
+        if now.timeIntervalSince(Self.lastRefreshModelsTime) < 60 {
+            return
+        }
+
+        Self.lastRefreshModelsTime = now
         let copilotModels = await SharedChatService.shared.copilotModels()
         if !copilotModels.isEmpty {
             CopilotModelManager.updateLLMs(copilotModels)

Core/Sources/ConversationTab/Views/ConversationProgressStepView.swift

@@ -29,6 +29,7 @@ struct StatusItemView: View {
             case .running:
                 ProgressView()
                     .controlSize(.small)
+                    .frame(width: 16, height: 16)
                     .scaleEffect(0.7)
             case .completed:
                 Image(systemName: "checkmark")

Core/Sources/GitHubCopilotViewModel/GitHubCopilotViewModel.swift

@@ -155,12 +155,12 @@ public class GitHubCopilotViewModel: ObservableObject {
                 waitingForSignIn = false
                 self.username = username
                 self.status = status
+                await Status.shared.updateAuthStatus(.loggedIn, username: username)
+                broadcastStatusChange()
                 let models = try? await service.models()
                 if let models = models, !models.isEmpty {
                     CopilotModelManager.updateLLMs(models)
                 }
-                await Status.shared.updateAuthStatus(.loggedIn, username: username)
-                broadcastStatusChange()
             } catch let error as GitHubCopilotError {
                 if case .languageServerError(.timeout) = error {
                     // TODO figure out how to extend the default timeout on a Chime LSP request

Core/Sources/PersistMiddleware/Extensions/ChatMessage+Storage.swift

@@ -14,6 +14,29 @@ extension ChatMessage {
         var suggestedTitle: String?
         var errorMessage: String?
         var steps: [ConversationProgressStep]
+
+        // Custom decoder to provide default value for steps
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            content = try container.decode(String.self, forKey: .content)
+            rating = try container.decode(ConversationRating.self, forKey: .rating)
+            references = try container.decode([ConversationReference].self, forKey: .references)
+            followUp = try container.decodeIfPresent(ConversationFollowUp.self, forKey: .followUp)
+            suggestedTitle = try container.decodeIfPresent(String.self, forKey: .suggestedTitle)
+            errorMessage = try container.decodeIfPresent(String.self, forKey: .errorMessage)
+            steps = try container.decodeIfPresent([ConversationProgressStep].self, forKey: .steps) ?? []
+        }
+
+        // Default memberwise init for encoding
+        init(content: String, rating: ConversationRating, references: [ConversationReference], followUp: ConversationFollowUp?, suggestedTitle: String?, errorMessage: String?, steps: [ConversationProgressStep]?) {
+            self.content = content
+            self.rating = rating
+            self.references = references
+            self.followUp = followUp
+            self.suggestedTitle = suggestedTitle
+            self.errorMessage = errorMessage
+            self.steps = steps ?? []
+        }
     }
 
     func toTurnItem() -> TurnItem {

Core/Sources/Service/Service.swift

@@ -94,24 +94,32 @@ public final class Service {
         keyBindingManager.start()
 
         Task {
-            await XcodeInspector.shared.safe.$activeDocumentURL
-                .removeDuplicates()
-                .filter { $0 != .init(fileURLWithPath: "/") }
-                .compactMap { $0 }
-                .sink { [weak self] fileURL in
-                    Task {
-                        do {
-                            let _ = try await self?.workspacePool
-                                .fetchOrCreateWorkspaceAndFilespace(fileURL: fileURL)
-                        } catch let error as Workspace.WorkspaceFileError {
-                            Logger.workspacePool
-                                .info(error.localizedDescription)
-                        }
-                        catch {
-                            Logger.workspacePool.error(error)
-                        }
+            await Publishers.CombineLatest(
+                XcodeInspector.shared.safe.$activeDocumentURL
+                    .removeDuplicates(),
+                XcodeInspector.shared.safe.$latestActiveXcode
+            )
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] documentURL, latestXcode in
+                Task {
+                    let fileURL = documentURL ?? latestXcode?.realtimeDocumentURL
+                    guard fileURL != nil, fileURL != .init(fileURLWithPath: "/") else {
+                        return
+                    }
+                    do {
+                        let _ = try await self?.workspacePool
+                            .fetchOrCreateWorkspaceAndFilespace(
+                                fileURL: fileURL!
+                            )
+                    } catch let error as Workspace.WorkspaceFileError {
+                        Logger.workspacePool
+                            .info(error.localizedDescription)
+                    }
+                    catch {
+                        Logger.workspacePool.error(error)
                     }
-                }.store(in: &cancellable)
+                }
+            }.store(in: &cancellable)
 
             // Combine both workspace and auth status changes into a single stream
             await Publishers.CombineLatest3(
@@ -202,13 +210,11 @@ extension Service {
         let name = self.getDisplayNameOfXcodeWorkspace(url: workspaceURL)
         let path = workspaceURL.path
 
-        // switch workspace and username
-        self.guiController.store.send(.switchWorkspace(path: path, name: name, username: username))
-        
+        // switch workspace and username and wait for it to complete
+        await self.guiController.store.send(.switchWorkspace(path: path, name: name, username: username)).finish()
         // restore if needed
         await self.guiController.restore(path: path, name: name, username: username)
-        
-        // init chat tab if no history tab
-        self.guiController.store.send(.initWorkspaceChatTabIfNeeded(path: path, username: username))
+        // init chat tab if no history tab (only after workspace is fully switched and restored)
+        await self.guiController.store.send(.initWorkspaceChatTabIfNeeded(path: path, username: username)).finish()
     }
 }

Core/Sources/SuggestionWidget/FeatureReducers/ChatPanelFeature.swift

@@ -513,10 +513,13 @@ public struct ChatPanelFeature {
                 if var existChatWorkspace = state.chatHistory.workspaces[id: chatWorkspace.id] {
 
                     if var selectedChatTabInfo = chatWorkspace.tabInfo.first(where: { $0.id == chatWorkspace.selectedTabId }) {
-                        // cancel selectedChatTabInfo in chat workspace
-                        selectedChatTabInfo.isSelected = false
+                        // Keep the selection state when restoring
+                        selectedChatTabInfo.isSelected = true
                         chatWorkspace.tabInfo[id: selectedChatTabInfo.id] = selectedChatTabInfo
 
+                        // Update the existing workspace's selected tab to match
+                        existChatWorkspace.selectedTabId = selectedChatTabInfo.id
+                        
                         // merge tab info
                         existChatWorkspace.tabInfo.append(contentsOf: chatWorkspace.tabInfo)
                         state.chatHistory.updateHistory(existChatWorkspace)

ExtensionService/AppDelegate.swift

@@ -180,10 +180,16 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
                     .userInfo?[NSWorkspace.applicationUserInfoKey] as? NSRunningApplication,
                     app.isUserOfService
                 else { continue }
-                if NSWorkspace.shared.runningApplications.contains(where: \.isUserOfService) {
-                    continue
+                
+                // Check if Xcode is running
+                let isXcodeRunning = NSWorkspace.shared.runningApplications.contains { 
+                    $0.bundleIdentifier == "com.apple.dt.Xcode" 
+                }
+                
+                if !isXcodeRunning {
+                    Logger.client.info("No Xcode instances running, preparing to quit")
+                    quit()
                 }
-                quit()
             }
         }
     }

Tool/Sources/ConversationServiceProvider/ConversationServiceProvider.swift

@@ -170,7 +170,7 @@ public struct ConversationProgressStep: Codable, Equatable, Identifiable {
     public let id: String
     public let title: String
     public let description: String?
-    public let status: StepStatus
+    public var status: StepStatus
     public let error: StepError?
 
     public init(id: String, title: String, description: String?, status: StepStatus, error: StepError?) {

Tool/Sources/GitHubCopilotService/Conversation/WatchedFilesHandler.swift

@@ -1,17 +1,55 @@
 import JSONRPC
 import Combine
+import Workspace
+import XcodeInspector
+import Foundation
 
 public protocol WatchedFilesHandler {
     var onWatchedFiles: PassthroughSubject<(WatchedFilesRequest, (AnyJSONRPCResponse) -> Void), Never> { get }
-    func handleWatchedFiles(_ request: WatchedFilesRequest, completion: @escaping (AnyJSONRPCResponse) -> Void)
+    func handleWatchedFiles(_ request: WatchedFilesRequest, workspaceURL: URL, completion: @escaping (AnyJSONRPCResponse) -> Void, service: GitHubCopilotService?)
 }
 
 public final class WatchedFilesHandlerImpl: WatchedFilesHandler {
     public static let shared = WatchedFilesHandlerImpl()
 
     public let onWatchedFiles: PassthroughSubject<(WatchedFilesRequest, (AnyJSONRPCResponse) -> Void), Never> = .init()
+    
+    public func handleWatchedFiles(_ request: WatchedFilesRequest, workspaceURL: URL, completion: @escaping (AnyJSONRPCResponse) -> Void, service: GitHubCopilotService?) {
+        guard let params = request.params, params.workspaceUri != "/" else { return }
 
-    public func handleWatchedFiles(_ request: WatchedFilesRequest, completion: @escaping (AnyJSONRPCResponse) -> Void) {
+        let projectURL = WorkspaceXcodeWindowInspector.extractProjectURL(workspaceURL: workspaceURL, documentURL: nil) ?? workspaceURL
+        
+        let files = WorkspaceFile.getWatchedFiles(
+            workspaceURL: workspaceURL,
+            projectURL: projectURL,
+            excludeGitIgnoredFiles: params.excludeGitignoredFiles,
+            excludeIDEIgnoredFiles: params.excludeIDEIgnoredFiles
+        )
+        
+        let batchSize = BatchingFileChangeWatcher.maxEventPublishSize
+        /// only `batchSize`(100) files to complete this event for setup watching workspace in CLS side
+        let jsonResult: JSONValue = .array(files.prefix(batchSize).map { .string($0) })
+        let jsonValue: JSONValue = .hash(["files": jsonResult])
+        
+        completion(AnyJSONRPCResponse(id: request.id, result: jsonValue))
+        
+        Task {
+            if files.count > batchSize {
+                for startIndex in stride(from: batchSize, to: files.count, by: batchSize) {
+                    let endIndex = min(startIndex + batchSize, files.count)
+                    let batch = Array(files[startIndex..<endIndex])
+                    try? await service?.notifyDidChangeWatchedFiles(.init(
+                        workspaceUri: params.workspaceUri,
+                        changes: batch.map { .init(uri: $0, type: .created)}
+                    ))
+                    
+                    try? await Task.sleep(nanoseconds: 100_000_000)  // 100ms
+                }
+            }
+        }
+        
+        /// publish event for watching workspace file changes
         onWatchedFiles.send((request, completion))
     }
 }
+