Support continuous mode in accepting content

Author: intitni

Core/Sources/Service/SuggestionCommandHandler/WindowBaseCommandHandler.swift

@@ -140,70 +140,64 @@ struct WindowBaseCommandHandler: SuggestionCommandHandler {
         let fileURL = try await Environment.fetchCurrentFileURL()
         let (workspace, _) = try await Workspace.fetchOrCreateWorkspaceIfNeeded(fileURL: fileURL)
 
-        let result: (
-            suggestion: CopilotCompletion,
-            cleanup: () -> Void,
-            startPosition: CursorPosition?
-        )? = {
-            if let service = WidgetDataSource.shared.promptToCodes[fileURL]?.promptToCodeService {
-                return (
-                    CopilotCompletion(
-                        text: service.code,
-                        position: service.selectionRange.start,
-                        uuid: UUID().uuidString,
-                        range: service.selectionRange,
-                        displayText: service.code
-                    ),
-                    {
-                        WidgetDataSource.shared.removePromptToCode(for: fileURL)
-                        presenter.closePromptToCode(fileURL: fileURL)
-                    },
-                    service.selectionRange.start
-                )
-            }
-
-            if let acceptedSuggestion = workspace.acceptSuggestion(
-                forFileAt: fileURL,
-                editor: editor
-            ) {
-                return (
-                    acceptedSuggestion,
-                    {
-                        presenter.discardSuggestion(fileURL: fileURL)
-                    },
-                    nil
-                )
-            }
-
-            return nil
-        }()
-
-        guard let result else { return nil }
-
         let injector = SuggestionInjector()
         var lines = editor.lines
         var cursorPosition = editor.cursorPosition
         var extraInfo = SuggestionInjector.ExtraInfo()
 
-        injector.acceptSuggestion(
-            intoContentWithoutSuggestion: &lines,
-            cursorPosition: &cursorPosition,
-            completion: result.suggestion,
-            extraInfo: &extraInfo
-        )
+        if let service = WidgetDataSource.shared.promptToCodes[fileURL]?.promptToCodeService {
+            let suggestion = CopilotCompletion(
+                text: service.code,
+                position: service.selectionRange.start,
+                uuid: UUID().uuidString,
+                range: service.selectionRange,
+                displayText: service.code
+            )
 
-        result.cleanup()
+            injector.acceptSuggestion(
+                intoContentWithoutSuggestion: &lines,
+                cursorPosition: &cursorPosition,
+                completion: suggestion,
+                extraInfo: &extraInfo
+            )
 
-        return .init(
-            content: String(lines.joined(separator: "")),
-            newSelection: {
-                if let startPosition = result.startPosition {
-                    return .init(start: startPosition, end: cursorPosition)
-                }
-                return .cursor(cursorPosition)
-            }(),
-            modifications: extraInfo.modifications
-        )
+            if service.isContinuous {
+                service.selectionRange = .init(
+                    start: service.selectionRange.start,
+                    end: cursorPosition
+                )
+                presenter.presentPromptToCode(fileURL: fileURL)
+            } else {
+                WidgetDataSource.shared.removePromptToCode(for: fileURL)
+                presenter.closePromptToCode(fileURL: fileURL)
+            }
+
+            return .init(
+                content: String(lines.joined(separator: "")),
+                newSelection: .init(start: service.selectionRange.start, end: cursorPosition),
+                modifications: extraInfo.modifications
+            )
+        } else if let acceptedSuggestion = workspace.acceptSuggestion(
+            forFileAt: fileURL,
+            editor: editor
+        ) {
+            injector.acceptSuggestion(
+                intoContentWithoutSuggestion: &lines,
+                cursorPosition: &cursorPosition,
+                completion: acceptedSuggestion,
+                extraInfo: &extraInfo
+            )
+
+            presenter.discardSuggestion(fileURL: fileURL)
+
+            return .init(
+                content: String(lines.joined(separator: "")),
+                newSelection: .cursor(cursorPosition),
+                modifications: extraInfo.modifications
+            )
+        }
+
+        return nil
     }
 
     func presentRealtimeSuggestions(editor: EditorContent) async throws -> UpdatedContent? {
@@ -348,13 +342,14 @@ struct WindowBaseCommandHandler: SuggestionCommandHandler {
         defer { presenter.markAsProcessing(false) }
         let fileURL = try await Environment.fetchCurrentFileURL()
         let codeLanguage = languageIdentifierFromFileURL(fileURL)
-        
+
         let (code, selection) = {
             guard var selection = editor.selections.last,
                   selection.start != selection.end
             else { return ("", .cursor(editor.cursorPosition)) }
             if selection.start.line != selection.end.line {
-                // when there are multiple lines start from char 0 so that it can keep the indentation.
+                // when there are multiple lines start from char 0 so that it can keep the
+                // indentation.
                 selection.start = .init(line: selection.start.line, character: 0)
             }
             return (

Core/Sources/SuggestionWidget/SuggestionPanelContent/PromptToCodePanel.swift

@@ -75,9 +75,15 @@ struct PromptToCodePanel: View {
                         .buttonStyle(.plain)
                     } else {
                         HStack {
-                            Toggle("Continuous Mode", isOn: $provider.isContinuous)
-                                .toggleStyle(.checkbox)
-                            
+                            Toggle(
+                                "Continuous Mode",
+                                isOn: .init(
+                                    get: { provider.isContinuous },
+                                    set: { _ in provider.toggleContinuous() }
+                                )
+                            )
+                            .toggleStyle(.checkbox)
+
                             Button(action: {
                                 provider.cancel()
                             }) {