Update prompt to code panel

Author: intitni

Core/Package.swift

@@ -86,6 +86,7 @@ let package = Package(
                 .product(name: "UserDefaultsObserver", package: "Tool"),
                 .product(name: "AppMonitoring", package: "Tool"),
                 .product(name: "SuggestionBasic", package: "Tool"),
+                .product(name: "PromptToCode", package: "Tool"),
                 .product(name: "ChatTab", package: "Tool"),
                 .product(name: "Logger", package: "Tool"),
                 .product(name: "OpenAIService", package: "Tool"),
@@ -152,6 +153,7 @@ let package = Package(
         .target(
             name: "PromptToCodeService",
             dependencies: [
+                .product(name: "PromptToCode", package: "Tool"),
                 .product(name: "FocusedCodeFinder", package: "Tool"),
                 .product(name: "SuggestionBasic", package: "Tool"),
                 .product(name: "OpenAIService", package: "Tool"),
@@ -219,6 +221,7 @@ let package = Package(
             dependencies: [
                 "PromptToCodeService",
                 "ChatGPTChatTab",
+                .product(name: "PromptToCode", package: "Tool"),
                 .product(name: "Toast", package: "Tool"),
                 .product(name: "UserDefaultsObserver", package: "Tool"),
                 .product(name: "SharedUIComponents", package: "Tool"),

Core/Sources/Service/GUI/GraphicalUserInterfaceController.swift

@@ -21,10 +21,10 @@ import ChatTabPersistent
 @Reducer
 struct GUI {
     @ObservableState
-    struct State: Equatable {
+    struct State {
         var suggestionWidgetState = Widget.State()
 
-        var chatTabGroup: ChatPanel.ChatTabGroup {
+        var chatTabGroup: SuggestionWidget.ChatPanel.ChatTabGroup {
             get { suggestionWidgetState.chatPanelState.chatTabGroup }
             set { suggestionWidgetState.chatPanelState.chatTabGroup = newValue }
         }
@@ -85,7 +85,7 @@ struct GUI {
     var body: some ReducerOf<Self> {
         CombineReducers {
             Scope(state: \.suggestionWidgetState, action: \.suggestionWidget) {
-                WidgetFeature()
+                Widget()
             }
 
             Scope(

Core/Sources/Service/SuggestionCommandHandler/WindowBaseCommandHandler.swift

@@ -1,12 +1,13 @@
 import AppKit
 import ChatService
+import ComposableArchitecture
 import Foundation
 import GitHubCopilotService
 import LanguageServerProtocol
 import Logger
 import OpenAIService
-import SuggestionInjector
 import SuggestionBasic
+import SuggestionInjector
 import SuggestionWidget
 import UserNotifications
 import Workspace
@@ -175,61 +176,78 @@ struct WindowBaseCommandHandler: SuggestionCommandHandler {
 
         let injector = SuggestionInjector()
         var lines = editor.lines
+        var ranges = [CursorRange]()
         var cursorPosition = editor.cursorPosition
         var extraInfo = SuggestionInjector.ExtraInfo()
 
         let store = await Service.shared.guiController.store
 
         if let promptToCode = store.state.promptToCodeGroup.activePromptToCode {
-            if promptToCode.isAttachedToSelectionRange, promptToCode.documentURL != fileURL {
+            if promptToCode.promptToCodeState.isAttachedToTarget,
+               promptToCode.promptToCodeState.source.documentURL != fileURL
+            {
                 return nil
             }
 
-            let range = {
-                if promptToCode.isAttachedToSelectionRange,
-                   let range = promptToCode.selectionRange
-                {
-                    return range
-                }
-                return editor.selections.first.map {
-                    CursorRange(start: $0.start, end: $0.end)
-                } ?? CursorRange(
-                    start: editor.cursorPosition,
-                    end: editor.cursorPosition
+            for snippet in promptToCode.promptToCodeState.snippets.sorted(by: { a, b in
+                a.attachedRange.start.line > b.attachedRange.start.line
+            }) {
+                let range = {
+                    if promptToCode.promptToCodeState.isAttachedToTarget {
+                        return snippet.attachedRange
+                    }
+                    return editor.selections.first.map {
+                        CursorRange(start: $0.start, end: $0.end)
+                    } ?? CursorRange(
+                        start: editor.cursorPosition,
+                        end: editor.cursorPosition
+                    )
+                }()
+
+                ranges.append(range)
+
+                let suggestion = CodeSuggestion(
+                    id: UUID().uuidString,
+                    text: snippet.modifiedCode,
+                    position: range.start,
+                    range: range
                 )
-            }()
 
-            let suggestion = CodeSuggestion(
-                id: UUID().uuidString,
-                text: promptToCode.code,
-                position: range.start,
-                range: range
-            )
+                injector.acceptSuggestion(
+                    intoContentWithoutSuggestion: &lines,
+                    cursorPosition: &cursorPosition,
+                    completion: suggestion,
+                    extraInfo: &extraInfo
+                )
 
-            injector.acceptSuggestion(
-                intoContentWithoutSuggestion: &lines,
-                cursorPosition: &cursorPosition,
-                completion: suggestion,
-                extraInfo: &extraInfo
-            )
+                _ = await Task { @MainActor [cursorPosition] in
+                    await store.send(
+                        .promptToCodeGroup(.updatePromptToCodeRange(
+                            id: promptToCode.id,
+                            snippetId: snippet.id,
+                            range: .init(start: range.start, end: cursorPosition)
+                        ))
+                    ).finish()
+                }.value
+            }
 
-            _ = await Task { @MainActor [cursorPosition] in
-                store.send(
-                    .promptToCodeGroup(.updatePromptToCodeRange(
-                        id: promptToCode.id,
-                        range: .init(start: range.start, end: cursorPosition)
-                    ))
-                )
+            _ = await MainActor.run {
                 store.send(
                     .promptToCodeGroup(.discardAcceptedPromptToCodeIfNotContinuous(
                         id: promptToCode.id
                     ))
                 )
-            }.result
+            }
 
             return .init(
                 content: String(lines.joined(separator: "")),
-                newSelection: .init(start: range.start, end: cursorPosition),
+                newSelection: {
+                    if ranges.isEmpty {
+                        .init(start: cursorPosition, end: cursorPosition)
+                    } else {
+                        ranges.last
+                    }
+                }(),
                 modifications: extraInfo.modifications
             )
         }
@@ -405,22 +423,24 @@ extension WindowBaseCommandHandler {
         }
 
         _ = await Task { @MainActor in
-            // if there is already a prompt to code presenting, we should not present another one
             store.send(.promptToCodeGroup(.activateOrCreatePromptToCode(.init(
-                code: code,
-                selectionRange: selection,
-                language: codeLanguage,
-                identSize: filespace.codeMetadata.indentSize ?? 4,
+                promptToCodeState: Shared(.init(
+                    source: .init(
+                        language: codeLanguage,
+                        documentURL: fileURL,
+                        projectRootURL: workspace.projectRootURL,
+                        content: editor.content,
+                        lines: editor.lines
+                    ),
+                    originalCode: code, 
+                    attachedRange: selection,
+                    instruction: newPrompt ?? "",
+                    extraSystemPrompt: newExtraSystemPrompt ?? ""
+                )),
+                indentSize: filespace.codeMetadata.indentSize ?? 4,
                 usesTabsForIndentation: filespace.codeMetadata.usesTabsForIndentation ?? false,
-                documentURL: fileURL,
-                projectRootURL: workspace.projectRootURL,
-                allCode: editor.content,
-                allLines: editor.lines,
-                isContinuous: isContinuous,
                 commandName: name,
-                defaultPrompt: newPrompt ?? "",
-                extraSystemPrompt: newExtraSystemPrompt,
-                generateDescriptionRequirement: generateDescription
+                isContinuous: isContinuous
             ))))
         }.result
     }

Core/Sources/SuggestionWidget/FeatureReducers/PromptToCodeGroup.swift

@@ -7,13 +7,15 @@ import XcodeInspector
 @Reducer
 public struct PromptToCodeGroup {
     @ObservableState
-    public struct State: Equatable {
+    public struct State {
         public var promptToCodes: IdentifiedArrayOf<PromptToCodePanel.State> = []
         public var activeDocumentURL: PromptToCodePanel.State.ID? = XcodeInspector.shared
             .realtimeActiveDocumentURL
         public var activePromptToCode: PromptToCodePanel.State? {
             get {
-                if let detached = promptToCodes.first(where: { !$0.isAttachedToSelectionRange }) {
+                if let detached = promptToCodes
+                    .first(where: { !$0.promptToCodeState.isAttachedToTarget })
+                {
                     return detached
                 }
                 guard let id = activeDocumentURL else { return nil }
@@ -27,60 +29,15 @@ public struct PromptToCodeGroup {
         }
     }
 
-    public struct PromptToCodeInitialState: Equatable {
-        public var code: String
-        public var selectionRange: CursorRange?
-        public var language: CodeLanguage
-        public var identSize: Int
-        public var usesTabsForIndentation: Bool
-        public var documentURL: URL
-        public var projectRootURL: URL
-        public var allCode: String
-        public var allLines: [String]
-        public var isContinuous: Bool
-        public var commandName: String?
-        public var defaultPrompt: String
-        public var extraSystemPrompt: String?
-        public var generateDescriptionRequirement: Bool?
-
-        public init(
-            code: String,
-            selectionRange: CursorRange?,
-            language: CodeLanguage,
-            identSize: Int,
-            usesTabsForIndentation: Bool,
-            documentURL: URL,
-            projectRootURL: URL,
-            allCode: String,
-            allLines: [String],
-            isContinuous: Bool,
-            commandName: String?,
-            defaultPrompt: String,
-            extraSystemPrompt: String?,
-            generateDescriptionRequirement: Bool?
-        ) {
-            self.code = code
-            self.selectionRange = selectionRange
-            self.language = language
-            self.identSize = identSize
-            self.usesTabsForIndentation = usesTabsForIndentation
-            self.documentURL = documentURL
-            self.projectRootURL = projectRootURL
-            self.allCode = allCode
-            self.allLines = allLines
-            self.isContinuous = isContinuous
-            self.commandName = commandName
-            self.defaultPrompt = defaultPrompt
-            self.extraSystemPrompt = extraSystemPrompt
-            self.generateDescriptionRequirement = generateDescriptionRequirement
-        }
-    }
-
-    public enum Action: Equatable {
+    public enum Action {
         /// Activate the prompt to code if it exists or create it if it doesn't
-        case activateOrCreatePromptToCode(PromptToCodeInitialState)
-        case createPromptToCode(PromptToCodeInitialState)
-        case updatePromptToCodeRange(id: PromptToCodePanel.State.ID, range: CursorRange)
+        case activateOrCreatePromptToCode(PromptToCodePanel.State)
+        case createPromptToCode(PromptToCodePanel.State)
+        case updatePromptToCodeRange(
+            id: PromptToCodePanel.State.ID,
+            snippetId: UUID,
+            range: CursorRange
+        )
         case discardAcceptedPromptToCodeIfNotContinuous(id: PromptToCodePanel.State.ID)
         case updateActivePromptToCode(documentURL: URL)
         case discardExpiredPromptToCode(documentURLs: [URL])
@@ -103,37 +60,22 @@ public struct PromptToCodeGroup {
                 return .run { send in
                     await send(.createPromptToCode(s))
                 }
-            case let .createPromptToCode(s):
-                let newPromptToCode = PromptToCodePanel.State(
-                    code: s.code,
-                    prompt: s.defaultPrompt,
-                    language: s.language,
-                    indentSize: s.identSize,
-                    usesTabsForIndentation: s.usesTabsForIndentation,
-                    projectRootURL: s.projectRootURL,
-                    documentURL: s.documentURL,
-                    allCode: s.allCode, 
-                    allLines: s.allLines,
-                    commandName: s.commandName,
-                    isContinuous: s.isContinuous,
-                    selectionRange: s.selectionRange,
-                    extraSystemPrompt: s.extraSystemPrompt,
-                    generateDescriptionRequirement: s.generateDescriptionRequirement
-                )
+            case let .createPromptToCode(newPromptToCode):
                 // insert at 0 so it has high priority then the other detached prompt to codes
                 state.promptToCodes.insert(newPromptToCode, at: 0)
                 return .run { send in
-                    if !newPromptToCode.prompt.isEmpty {
+                    if !newPromptToCode.promptToCodeState.instruction.isEmpty {
                         await send(.promptToCode(newPromptToCode.id, .modifyCodeButtonTapped))
                     }
                 }.cancellable(
                     id: PromptToCodePanel.CancellationKey.modifyCode(newPromptToCode.id),
                     cancelInFlight: true
                 )
 
-            case let .updatePromptToCodeRange(id, range):
-                if let p = state.promptToCodes[id: id], p.isAttachedToSelectionRange {
-                    state.promptToCodes[id: id]?.selectionRange = range
+            case let .updatePromptToCodeRange(id, snippetId, range):
+                if let p = state.promptToCodes[id: id], p.promptToCodeState.isAttachedToTarget {
+                    state.promptToCodes[id: id]?.promptToCodeState.snippets[id: snippetId]?
+                        .attachedRange = range
                 }
                 return .none
 
@@ -153,7 +95,7 @@ public struct PromptToCodeGroup {
 
             case .promptToCode:
                 return .none
-                
+
             case .activePromptToCode:
                 return .none
             }
@@ -166,7 +108,7 @@ public struct PromptToCodeGroup {
             PromptToCodePanel()
                 .dependency(\.promptToCodeService, promptToCodeServiceFactory())
         })
-        
+
         Reduce { state, action in
             switch action {
             case let .promptToCode(id, .cancelButtonTapped):