Merge remote-tracking branch 'upstream/main'

Author: hashim2266

CHANGELOG.md

@@ -5,6 +5,31 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.37.0 - June 18, 2025
+### Added
+- **Advanced** settings: Added option to configure **Custom Instructions** for GitHub Copilot during chat sessions.
+- **Advanced** settings: Added option to keep the chat window automatically attached to Xcode.
+
+### Changed
+- Enabled support for dragging-and-dropping files into the chat panel to provide context.
+
+### Fixed
+- "Add Context" menu didn’t show files in workspaces organized with Xcode’s group feature.
+- Chat didn’t respond when the workspace was in a system folder (like Desktop, Downloads, or Documents) and access permission hadn’t been granted.
+
+## 0.36.0 - June 4, 2025
+### Added
+- Introduced a new chat setting "**Response Language**" under **Advanced** settings to customize the natural language used in chat replies.
+- Enabled support for custom instructions defined in _.github/copilot-instructions.md_ within your workspace.
+- Added support for premium request handling.
+
+### Fixed
+- Performance: Improved UI responsiveness by lazily restoring chat history.
+- Performance: Fixed lagging issue when pasting large text into the chat input.
+- Performance: Improved project indexing performance.
+- Don't trigger / (slash) commands when pasting a file path into the chat input.
+- Adjusted terminal text styling to align with Xcode’s theme.
+
 ## 0.35.0 - May 19, 2025
 ### Added
 - Launched Agent Mode. Copilot will automatically use multiple requests to edit files, run terminal commands, and fix errors.

Core/Package.swift

@@ -180,7 +180,8 @@ let package = Package(
                     .product(name: "ConversationServiceProvider", package: "Tool"),
                     .product(name: "GitHubCopilotService", package: "Tool"),
                     .product(name: "Workspace", package: "Tool"),
-                    .product(name: "Terminal", package: "Tool")
+                    .product(name: "Terminal", package: "Tool"),
+                    .product(name: "SystemUtils", package: "Tool")
                 ]),
             .testTarget(
                 name: "ChatServiceTests",

Core/Sources/ChatService/ChatService.swift

@@ -14,10 +14,11 @@ import Logger
 import Workspace
 import XcodeInspector
 import OrderedCollections
+import SystemUtils
 
 public protocol ChatServiceType {
     var memory: ContextAwareAutoManagedChatMemory { get set }
-    func send(_ id: String, content: String, skillSet: [ConversationSkill], references: [FileReference], model: String?, agentMode: Bool) async throws
+    func send(_ id: String, content: String, skillSet: [ConversationSkill], references: [FileReference], model: String?, agentMode: Bool, userLanguage: String?, turnId: String?) async throws
     func stopReceivingMessage() async
     func upvote(_ id: String, _ rating: ConversationRating) async
     func downvote(_ id: String, _ rating: ConversationRating) async
@@ -79,6 +80,7 @@ public final class ChatService: ChatServiceType, ObservableObject {
     private var activeRequestId: String?
     private(set) public var conversationId: String?
     private var skillSet: [ConversationSkill] = []
+    private var lastUserRequest: ConversationRequest?
     private var isRestored: Bool = false
     private var pendingToolCallRequests: [String: ToolCallRequest] = [:]
     init(provider: any ConversationServiceProvider,
@@ -98,6 +100,18 @@ public final class ChatService: ChatServiceType, ObservableObject {
         subscribeToClientToolConfirmationEvent()
     }
 
+    deinit {
+        Task { [weak self] in
+            await self?.stopReceivingMessage()
+        }
+        
+        // Clear all subscriptions
+        cancellables.forEach { $0.cancel() }
+        cancellables.removeAll()
+        
+        // Memory will be deallocated automatically
+    }
+    
     private func subscribeToNotifications() {
         memory.observeHistoryChange { [weak self] in
             Task { [weak self] in
@@ -303,19 +317,52 @@ public final class ChatService: ChatServiceType, ObservableObject {
         }
     }
 
-    public func send(_ id: String, content: String, skillSet: Array<ConversationSkill>, references: Array<FileReference>, model: String? = nil, agentMode: Bool = false) async throws {
+    public func send(
+        _ id: String,
+        content: String,
+        skillSet: Array<ConversationSkill>,
+        references: Array<FileReference>,
+        model: String? = nil,
+        agentMode: Bool = false,
+        userLanguage: String? = nil,
+        turnId: String? = nil
+    ) async throws {
         guard activeRequestId == nil else { return }
         let workDoneToken = UUID().uuidString
         activeRequestId = workDoneToken
 
-        let chatMessage = ChatMessage(
+        var chatMessage = ChatMessage(
             id: id,
             chatTabID: self.chatTabInfo.id,
             role: .user,
             content: content,
             references: references.toConversationReferences()
         )
-        await memory.appendMessage(chatMessage)
+        
+        let currentEditorSkill = skillSet.first(where: { $0.id == CurrentEditorSkill.ID }) as? CurrentEditorSkill
+        let currentFileReadability = currentEditorSkill == nil
+            ? nil
+            : FileUtils.checkFileReadability(at: currentEditorSkill!.currentFilePath)
+        var errorMessage: ChatMessage?
+        
+        var currentTurnId: String? = turnId
+        // If turnId is provided, it is used to update the existing message, no need to append the user message
+        if turnId == nil {
+            if let currentFileReadability, !currentFileReadability.isReadable {
+                // For associating error message with user message
+                currentTurnId = UUID().uuidString
+                chatMessage.clsTurnID = currentTurnId
+                errorMessage = buildErrorMessage(
+                    turnId: currentTurnId!,
+                    errorMessages: [
+                        currentFileReadability.errorMessage(
+                            using: CurrentEditorSkill.readabilityErrorMessageProvider
+                        )
+                    ].compactMap { $0 }.filter { !$0.isEmpty }
+                )
+            }
+            await memory.appendMessage(chatMessage)
+        }
 
         // reset file edits
         self.resetFileEdits()
@@ -344,28 +391,68 @@ public final class ChatService: ChatServiceType, ObservableObject {
             return
         }
 
-        let skillCapabilities: [String] = [ CurrentEditorSkill.ID, ProblemsInActiveDocumentSkill.ID ]
+        if let errorMessage {
+            Task { await memory.appendMessage(errorMessage) }
+        }
+        
+        var activeDoc: Doc?
+        var validSkillSet: [ConversationSkill] = skillSet
+        if let currentEditorSkill, currentFileReadability?.isReadable == true {
+            activeDoc = Doc(uri: currentEditorSkill.currentFile.url.absoluteString)
+        } else {
+            validSkillSet.removeAll(where: { $0.id == CurrentEditorSkill.ID || $0.id == ProblemsInActiveDocumentSkill.ID })
+        }
+        
+        let request = createConversationRequest(
+            workDoneToken: workDoneToken,
+            content: content,
+            activeDoc: activeDoc,
+            references: references,
+            model: model,
+            agentMode: agentMode,
+            userLanguage: userLanguage,
+            turnId: currentTurnId,
+            skillSet: validSkillSet
+        )
+        
+        self.lastUserRequest = request
+        self.skillSet = validSkillSet
+        try await send(request)
+    }
+    
+    private func createConversationRequest(
+        workDoneToken: String, 
+        content: String,
+        activeDoc: Doc?,
+        references: [FileReference],
+        model: String? = nil,
+        agentMode: Bool = false,
+        userLanguage: String? = nil,
+        turnId: String? = nil,
+        skillSet: [ConversationSkill]
+    ) -> ConversationRequest {
+        let skillCapabilities: [String] = [CurrentEditorSkill.ID, ProblemsInActiveDocumentSkill.ID]
         let supportedSkills: [String] = skillSet.map { $0.id }
         let ignoredSkills: [String] = skillCapabilities.filter {
             !supportedSkills.contains($0)
         }
-        let currentEditorSkill = skillSet.first { $0.id == CurrentEditorSkill.ID }
-        let activeDoc: Doc? = (currentEditorSkill as? CurrentEditorSkill).map { Doc(uri: $0.currentFile.url.absoluteString) }
 
         /// replace the `@workspace` to `@project`
         let newContent = replaceFirstWord(in: content, from: "@workspace", to: "@project")
 
-        let request = ConversationRequest(workDoneToken: workDoneToken,
-                                          content: newContent,
-                                          workspaceFolder: "",
-                                          activeDoc: activeDoc,
-                                          skills: skillCapabilities,
-                                          ignoredSkills: ignoredSkills,
-                                          references: references,
-                                          model: model,
-                                          agentMode: agentMode)
-        self.skillSet = skillSet
-        try await send(request)
+        return ConversationRequest(
+            workDoneToken: workDoneToken,
+            content: newContent,
+            workspaceFolder: "",
+            activeDoc: activeDoc,
+            skills: skillCapabilities,
+            ignoredSkills: ignoredSkills,
+            references: references,
+            model: model,
+            agentMode: agentMode,
+            userLanguage: userLanguage,
+            turnId: turnId
+        )
     }
 
     public func sendAndWait(_ id: String, content: String) async throws -> String {
@@ -408,15 +495,22 @@ public final class ChatService: ChatServiceType, ObservableObject {
         deleteChatMessageFromStorage(id)
     }
 
-    // Not used for now
-    public func resendMessage(id: String) async throws {
-        if let message = (await memory.history).first(where: { $0.id == id })
+    public func resendMessage(id: String, model: String? = nil) async throws {
+        if let _ = (await memory.history).first(where: { $0.id == id }),
+           let lastUserRequest
         {
-            do {
-                try await send(id, content: message.content, skillSet: [], references: [])
-            } catch {
-                print("Failed to resend message")
-            }
+            // TODO: clean up contents for resend message
+            activeRequestId = nil
+            try await send(
+                id,
+                content: lastUserRequest.content,
+                skillSet: skillSet,
+                references: lastUserRequest.references ?? [],
+                model: model != nil ? model : lastUserRequest.model,
+                agentMode: lastUserRequest.agentMode,
+                userLanguage: lastUserRequest.userLanguage,
+                turnId: id
+            )
         }
     }
 
@@ -528,6 +622,19 @@ public final class ChatService: ChatServiceType, ObservableObject {
 
         Task {
             if var lastUserMessage = await memory.history.last(where: { $0.role == .user }) {
+                
+                // Case: New conversation where error message was generated before CLS request
+                // Using clsTurnId to associate this error message with the corresponding user message
+                // When merging error messages with bot responses from CLS, these properties need to be updated
+                await memory.mutateHistory { history in 
+                    if let existingBotIndex = history.lastIndex(where: {
+                        $0.role == .assistant && $0.clsTurnID == lastUserMessage.clsTurnID
+                    }) {
+                        history[existingBotIndex].id = turnId
+                        history[existingBotIndex].clsTurnID = turnId
+                    }
+                }
+                
                 lastUserMessage.clsTurnID = progress.turnId
                 saveChatMessageToStorage(lastUserMessage)
             }
@@ -611,45 +718,49 @@ public final class ChatService: ChatServiceType, ObservableObject {
             if CLSError.code == 402 {
                 Task {
                     await Status.shared
-                        .updateCLSStatus(.error, busy: false, message: CLSError.message)
-                    let errorMessage = ChatMessage(
-                        id: progress.turnId,
-                        chatTabID: self.chatTabInfo.id,
-                        clsTurnID: progress.turnId,
-                        role: .system,
-                        content: CLSError.message
-                    )
+                        .updateCLSStatus(.warning, busy: false, message: CLSError.message)
+                    let errorMessage = buildErrorMessage(
+                        turnId: progress.turnId, 
+                        panelMessages: [.init(type: .error, title: String(CLSError.code ?? 0), message: CLSError.message, location: .Panel)])
                     // will persist in resetongoingRequest()
-                    await memory.removeMessage(progress.turnId)
                     await memory.appendMessage(errorMessage)
+                    
+                    if let lastUserRequest {
+                        guard let fallbackModel = CopilotModelManager.getFallbackLLM(
+                            scope: lastUserRequest.agentMode ? .agentPanel : .chatPanel
+                        ) else {
+                            resetOngoingRequest()
+                            return
+                        }
+                        do {
+                            CopilotModelManager.switchToFallbackModel()
+                            try await resendMessage(id: progress.turnId, model: fallbackModel.id)
+                        } catch {
+                            Logger.gitHubCopilot.error(error)
+                            resetOngoingRequest()
+                        }
+                        return
+                    }
                 }
             } else if CLSError.code == 400 && CLSError.message.contains("model is not supported") {
                 Task {
-                    let errorMessage = ChatMessage(
-                        id: progress.turnId,
-                        chatTabID: self.chatTabInfo.id,
-                        role: .assistant,
-                        content: "",
-                        errorMessage: "Oops, the model is not supported. Please enable it first in [GitHub Copilot settings](https://github.com/settings/copilot)."
+                    let errorMessage = buildErrorMessage(
+                        turnId: progress.turnId, 
+                        errorMessages: ["Oops, the model is not supported. Please enable it first in [GitHub Copilot settings](https://github.com/settings/copilot)."]
                     )
                     await memory.appendMessage(errorMessage)
+                    resetOngoingRequest()
+                    return
                 }
             } else {
                 Task {
-                    let errorMessage = ChatMessage(
-                        id: progress.turnId,
-                        chatTabID: self.chatTabInfo.id,
-                        clsTurnID: progress.turnId,
-                        role: .assistant,
-                        content: "",
-                        errorMessage: CLSError.message
-                    )
+                    let errorMessage = buildErrorMessage(turnId: progress.turnId, errorMessages: [CLSError.message])
                     // will persist in resetOngoingRequest()
                     await memory.appendMessage(errorMessage)
+                    resetOngoingRequest()
+                    return
                 }
             }
-            resetOngoingRequest()
-            return
         }
 
         Task {
@@ -664,9 +775,24 @@ public final class ChatService: ChatServiceType, ObservableObject {
             )
             // will persist in resetOngoingRequest()
             await memory.appendMessage(message)
+            resetOngoingRequest()
         }
-        
-        resetOngoingRequest()
+    }
+    
+    private func buildErrorMessage(
+        turnId: String, 
+        errorMessages: [String] = [], 
+        panelMessages: [CopilotShowMessageParams] = []
+    ) -> ChatMessage {
+        return .init(
+            id: turnId,
+            chatTabID: chatTabInfo.id,
+            clsTurnID: turnId,
+            role: .assistant,
+            content: "",
+            errorMessages: errorMessages,
+            panelMessages: panelMessages
+        )
     }
 
     private func resetOngoingRequest() {
@@ -732,7 +858,12 @@ public final class ChatService: ChatServiceType, ObservableObject {
 
         do {
             if let conversationId = conversationId {
-                try await conversationProvider?.createTurn(with: conversationId, request: request, workspaceURL: getWorkspaceURL())
+                try await conversationProvider?
+                    .createTurn(
+                        with: conversationId,
+                        request: request,
+                        workspaceURL: getWorkspaceURL()
+                    )
             } else {
                 var requestWithTurns = request
 

Core/Sources/ChatService/ContextAwareAutoManagedChatMemory.swift

@@ -18,6 +18,8 @@ public final class ContextAwareAutoManagedChatMemory: ChatMemory {
             systemPrompt: ""
         )
     }
+    
+    deinit { }
 
     public func mutateHistory(_ update: (inout [ChatMessage]) -> Void) async {
         await memory.mutateHistory(update)