feat(amazonq): inline suggestions are served by language server.

packages/amazonq/.changes/next-release/Bug Fix-bb976b5f-7697-42d8-89a9-8e96310a23f4.json

@@ -0,0 +1,4 @@
+{
+	"type": "Bug Fix",
+	"description": "Support chat in AL2 aarch64"
+}

packages/amazonq/src/app/chat/activation.ts

@@ -6,22 +6,14 @@
 import * as vscode from 'vscode'
 import { ExtensionContext } from 'vscode'
 import { telemetry } from 'aws-core-vscode/telemetry'
-import { AuthUtil, CodeWhispererSettings } from 'aws-core-vscode/codewhisperer'
-import { Commands, placeholder, funcUtil } from 'aws-core-vscode/shared'
+import { AuthUtil } from 'aws-core-vscode/codewhisperer'
+import { Commands, placeholder } from 'aws-core-vscode/shared'
 import * as amazonq from 'aws-core-vscode/amazonq'
 
 export async function activate(context: ExtensionContext) {
     const appInitContext = amazonq.DefaultAmazonQAppInitContext.instance
     await amazonq.TryChatCodeLensProvider.register(appInitContext.onDidChangeAmazonQVisibility.event)
 
-    const setupLsp = funcUtil.debounce(async () => {
-        void amazonq.LspController.instance.trySetupLsp(context, {
-            startUrl: AuthUtil.instance.connection?.startUrl,
-            maxIndexSize: CodeWhispererSettings.instance.getMaxIndexSize(),
-            isVectorIndexEnabled: false,
-        })
-    }, 5000)
-
     context.subscriptions.push(
         amazonq.focusAmazonQChatWalkthrough.register(),
         amazonq.walkthroughInlineSuggestionsExample.register(),
@@ -37,7 +29,6 @@ export async function activate(context: ExtensionContext) {
         void vscode.env.openExternal(vscode.Uri.parse(amazonq.amazonQHelpUrl))
     })
 
-    void setupLsp()
     void setupAuthNotification()
 }
 

packages/amazonq/src/app/inline/activation.ts

@@ -6,68 +6,26 @@
 import vscode from 'vscode'
 import {
     AuthUtil,
-    CodeSuggestionsState,
-    CodeWhispererCodeCoverageTracker,
     CodeWhispererConstants,
-    CodeWhispererSettings,
-    ConfigurationEntry,
-    DefaultCodeWhispererClient,
-    invokeRecommendation,
     isInlineCompletionEnabled,
-    KeyStrokeHandler,
-    RecommendationHandler,
     runtimeLanguageContext,
     TelemetryHelper,
     UserWrittenCodeTracker,
     vsCodeState,
 } from 'aws-core-vscode/codewhisperer'
-import { Commands, getLogger, globals, sleep } from 'aws-core-vscode/shared'
+import { globals, sleep } from 'aws-core-vscode/shared'
 
 export async function activate() {
-    const codewhispererSettings = CodeWhispererSettings.instance
-    const client = new DefaultCodeWhispererClient()
-
     if (isInlineCompletionEnabled()) {
         await setSubscriptionsforInlineCompletion()
         await AuthUtil.instance.setVscodeContextProps()
     }
 
-    function getAutoTriggerStatus(): boolean {
-        return CodeSuggestionsState.instance.isSuggestionsEnabled()
-    }
-
-    async function getConfigEntry(): Promise<ConfigurationEntry> {
-        const isShowMethodsEnabled: boolean =
-            vscode.workspace.getConfiguration('editor').get('suggest.showMethods') || false
-        const isAutomatedTriggerEnabled: boolean = getAutoTriggerStatus()
-        const isManualTriggerEnabled: boolean = true
-        const isSuggestionsWithCodeReferencesEnabled = codewhispererSettings.isSuggestionsWithCodeReferencesEnabled()
-
-        // TODO:remove isManualTriggerEnabled
-        return {
-            isShowMethodsEnabled,
-            isManualTriggerEnabled,
-            isAutomatedTriggerEnabled,
-            isSuggestionsWithCodeReferencesEnabled,
-        }
-    }
-
     async function setSubscriptionsforInlineCompletion() {
-        RecommendationHandler.instance.subscribeSuggestionCommands()
-
         /**
          * Automated trigger
          */
         globals.context.subscriptions.push(
-            vscode.window.onDidChangeActiveTextEditor(async (editor) => {
-                await RecommendationHandler.instance.onEditorChange()
-            }),
-            vscode.window.onDidChangeWindowState(async (e) => {
-                await RecommendationHandler.instance.onFocusChange()
-            }),
-            vscode.window.onDidChangeTextEditorSelection(async (e) => {
-                await RecommendationHandler.instance.onCursorChange(e)
-            }),
             vscode.workspace.onDidChangeTextDocument(async (e) => {
                 const editor = vscode.window.activeTextEditor
                 if (!editor) {
@@ -80,7 +38,6 @@ export async function activate() {
                     return
                 }
 
-                CodeWhispererCodeCoverageTracker.getTracker(e.document.languageId)?.countTotalTokens(e)
                 UserWrittenCodeTracker.instance.onTextDocumentChange(e)
                 /**
                  * Handle this keystroke event only when
@@ -105,19 +62,6 @@ export async function activate() {
                  * Then this event can be processed by our code.
                  */
                 await sleep(CodeWhispererConstants.vsCodeCursorUpdateDelay)
-                if (!RecommendationHandler.instance.isSuggestionVisible()) {
-                    await KeyStrokeHandler.instance.processKeyStroke(e, editor, client, await getConfigEntry())
-                }
-            }),
-            // manual trigger
-            Commands.register({ id: 'aws.amazonq.invokeInlineCompletion', autoconnect: true }, async () => {
-                invokeRecommendation(
-                    vscode.window.activeTextEditor as vscode.TextEditor,
-                    client,
-                    await getConfigEntry()
-                ).catch((e) => {
-                    getLogger().error('invokeRecommendation failed: %s', (e as Error).message)
-                })
             })
         )
     }

packages/amazonq/src/app/inline/completion.ts

@@ -8,14 +8,15 @@ import {
     InlineCompletionContext,
     InlineCompletionItem,
     InlineCompletionItemProvider,
-    InlineCompletionList,
     Position,
     TextDocument,
     commands,
     languages,
     Disposable,
     window,
     TextEditor,
+    InlineCompletionTriggerKind,
+    Range,
 } from 'vscode'
 import { LanguageClient } from 'vscode-languageclient'
 import {
@@ -27,37 +28,63 @@ import { RecommendationService } from './recommendationService'
 import {
     CodeWhispererConstants,
     ReferenceHoverProvider,
-    ReferenceInlineProvider,
     ReferenceLogViewProvider,
     ImportAdderProvider,
+    CodeSuggestionsState,
+    vsCodeState,
+    inlineCompletionsDebounceDelay,
+    noInlineSuggestionsMsg,
+    ReferenceInlineProvider,
 } from 'aws-core-vscode/codewhisperer'
+import { InlineGeneratingMessage } from './inlineGeneratingMessage'
+import { LineTracker } from './stateTracker/lineTracker'
+import { InlineTutorialAnnotation } from './tutorials/inlineTutorialAnnotation'
+import { TelemetryHelper } from './telemetryHelper'
+import { getLogger } from 'aws-core-vscode/shared'
+import { debounce, messageUtils } from 'aws-core-vscode/utils'
 
 export class InlineCompletionManager implements Disposable {
     private disposable: Disposable
     private inlineCompletionProvider: AmazonQInlineCompletionItemProvider
     private languageClient: LanguageClient
     private sessionManager: SessionManager
     private recommendationService: RecommendationService
+    private lineTracker: LineTracker
+    private incomingGeneratingMessage: InlineGeneratingMessage
+    private inlineTutorialAnnotation: InlineTutorialAnnotation
     private readonly logSessionResultMessageName = 'aws/logInlineCompletionSessionResults'
 
-    constructor(languageClient: LanguageClient) {
+    constructor(
+        languageClient: LanguageClient,
+        sessionManager: SessionManager,
+        lineTracker: LineTracker,
+        inlineTutorialAnnotation: InlineTutorialAnnotation
+    ) {
         this.languageClient = languageClient
-        this.sessionManager = new SessionManager()
-        this.recommendationService = new RecommendationService(this.sessionManager)
+        this.sessionManager = sessionManager
+        this.lineTracker = lineTracker
+        this.incomingGeneratingMessage = new InlineGeneratingMessage(this.lineTracker)
+        this.recommendationService = new RecommendationService(this.sessionManager, this.incomingGeneratingMessage)
+        this.inlineTutorialAnnotation = inlineTutorialAnnotation
         this.inlineCompletionProvider = new AmazonQInlineCompletionItemProvider(
             languageClient,
             this.recommendationService,
-            this.sessionManager
+            this.sessionManager,
+            this.inlineTutorialAnnotation
         )
         this.disposable = languages.registerInlineCompletionItemProvider(
             CodeWhispererConstants.platformLanguageIds,
             this.inlineCompletionProvider
         )
+
+        this.lineTracker.ready()
     }
 
     public dispose(): void {
         if (this.disposable) {
             this.disposable.dispose()
+            this.incomingGeneratingMessage.dispose()
+            this.lineTracker.dispose()
         }
     }
 
@@ -97,10 +124,21 @@ export class InlineCompletionManager implements Disposable {
                 )
                 ReferenceLogViewProvider.instance.addReferenceLog(referenceLog)
                 ReferenceHoverProvider.instance.addCodeReferences(item.insertText as string, item.references)
+
+                // Show codelense for 5 seconds.
+                ReferenceInlineProvider.instance.setInlineReference(
+                    startLine,
+                    item.insertText as string,
+                    item.references
+                )
+                setTimeout(() => {
+                    ReferenceInlineProvider.instance.removeInlineReference()
+                }, 5000)
             }
             if (item.mostRelevantMissingImports?.length) {
                 await ImportAdderProvider.instance.onAcceptRecommendation(editor, item, startLine)
             }
+            this.sessionManager.incrementSuggestionCount()
         }
         commands.registerCommand('aws.amazonq.acceptInline', onInlineAcceptance)
 
@@ -130,38 +168,6 @@ export class InlineCompletionManager implements Disposable {
             this.languageClient.sendNotification(this.logSessionResultMessageName, params)
         }
         commands.registerCommand('aws.amazonq.rejectCodeSuggestion', onInlineRejection)
-
-        /*
-            We have to overwrite the prev. and next. commands because the inlineCompletionProvider only contained the current item
-            To show prev. and next. recommendation we need to re-register a new provider with the previous or next item
-        */
-
-        const swapProviderAndShow = async () => {
-            await commands.executeCommand('editor.action.inlineSuggest.hide')
-            this.disposable.dispose()
-            this.disposable = languages.registerInlineCompletionItemProvider(
-                CodeWhispererConstants.platformLanguageIds,
-                new AmazonQInlineCompletionItemProvider(
-                    this.languageClient,
-                    this.recommendationService,
-                    this.sessionManager,
-                    false
-                )
-            )
-            await commands.executeCommand('editor.action.inlineSuggest.trigger')
-        }
-
-        const prevCommandHandler = async () => {
-            this.sessionManager.decrementActiveIndex()
-            await swapProviderAndShow()
-        }
-        commands.registerCommand('editor.action.inlineSuggest.showPrevious', prevCommandHandler)
-
-        const nextCommandHandler = async () => {
-            this.sessionManager.incrementActiveIndex()
-            await swapProviderAndShow()
-        }
-        commands.registerCommand('editor.action.inlineSuggest.showNext', nextCommandHandler)
     }
 }
 
@@ -170,52 +176,82 @@ export class AmazonQInlineCompletionItemProvider implements InlineCompletionItem
         private readonly languageClient: LanguageClient,
         private readonly recommendationService: RecommendationService,
         private readonly sessionManager: SessionManager,
-        private readonly isNewSession: boolean = true
+        private readonly inlineTutorialAnnotation: InlineTutorialAnnotation
     ) {}
 
-    async provideInlineCompletionItems(
+    provideInlineCompletionItems = debounce(
+        this._provideInlineCompletionItems.bind(this),
+        inlineCompletionsDebounceDelay,
+        true
+    )
+
+    private async _provideInlineCompletionItems(
         document: TextDocument,
         position: Position,
         context: InlineCompletionContext,
         token: CancellationToken
-    ): Promise<InlineCompletionItem[] | InlineCompletionList> {
-        if (this.isNewSession) {
-            // make service requests if it's a new session
+    ): Promise<InlineCompletionItem[]> {
+        try {
+            vsCodeState.isRecommendationsActive = true
+            const isAutoTrigger = context.triggerKind === InlineCompletionTriggerKind.Automatic
+            if (isAutoTrigger && !CodeSuggestionsState.instance.isSuggestionsEnabled()) {
+                // return early when suggestions are disabled with auto trigger
+                return []
+            }
+
+            // tell the tutorial that completions has been triggered
+            await this.inlineTutorialAnnotation.triggered(context.triggerKind)
+            TelemetryHelper.instance.setInvokeSuggestionStartTime()
+            TelemetryHelper.instance.setTriggerType(context.triggerKind)
+
             await this.recommendationService.getAllRecommendations(
                 this.languageClient,
                 document,
                 position,
                 context,
                 token
             )
-        }
-        // get active item from session for displaying
-        const items = this.sessionManager.getActiveRecommendation()
-        const session = this.sessionManager.getActiveSession()
-        if (!session || !items.length) {
-            return []
-        }
-        const editor = window.activeTextEditor
-        for (const item of items) {
-            item.command = {
-                command: 'aws.amazonq.acceptInline',
-                title: 'On acceptance',
-                arguments: [
-                    session.sessionId,
-                    item,
-                    editor,
-                    session.requestStartTime,
-                    position.line,
-                    session.firstCompletionDisplayLatency,
-                ],
+            // get active item from session for displaying
+            const items = this.sessionManager.getActiveRecommendation()
+            const session = this.sessionManager.getActiveSession()
+            const editor = window.activeTextEditor
+
+            // Show message to user when manual invoke fails to produce results.
+            if (items.length === 0 && context.triggerKind === InlineCompletionTriggerKind.Invoke) {
+                void messageUtils.showTimedMessage(noInlineSuggestionsMsg, 2000)
             }
-            ReferenceInlineProvider.instance.setInlineReference(
-                position.line,
-                item.insertText as string,
-                item.references
-            )
-            ImportAdderProvider.instance.onShowRecommendation(document, position.line, item)
+
+            if (!session || !items.length || !editor) {
+                getLogger().debug(
+                    `Failed to produce inline suggestion results. Received ${items.length} items from service`
+                )
+                return []
+            }
+
+            const cursorPosition = document.validatePosition(position)
+            for (const item of items) {
+                item.command = {
+                    command: 'aws.amazonq.acceptInline',
+                    title: 'On acceptance',
+                    arguments: [
+                        session.sessionId,
+                        item,
+                        editor,
+                        session.requestStartTime,
+                        cursorPosition.line,
+                        session.firstCompletionDisplayLatency,
+                    ],
+                }
+                item.range = new Range(cursorPosition, cursorPosition)
+                item.insertText = typeof item.insertText === 'string' ? item.insertText : item.insertText.value
+                ImportAdderProvider.instance.onShowRecommendation(document, cursorPosition.line, item)
+            }
+            return items as InlineCompletionItem[]
+        } catch (e) {
+            getLogger('amazonqLsp').error('Failed to provide completion items: %O', e)
+            return []
+        } finally {
+            vsCodeState.isRecommendationsActive = false
         }
-        return items as InlineCompletionItem[]
     }
 }