feat(amazonq): merge inline suggestions into flare mega branch.

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 {
@@ -30,34 +31,60 @@ import {
     ReferenceInlineProvider,
     ReferenceLogViewProvider,
     ImportAdderProvider,
+    CodeSuggestionsState,
+    vsCodeState,
+    inlineCompletionsDebounceDelay,
+    noInlineSuggestionsMsg,
+    LineTracker,
 } from 'aws-core-vscode/codewhisperer'
+import { InlineGeneratingMessage } from './inlineGeneratingMessage'
+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()
         }
     }
 
@@ -101,6 +128,7 @@ export class InlineCompletionManager implements Disposable {
             if (item.mostRelevantMissingImports?.length) {
                 await ImportAdderProvider.instance.onAcceptRecommendation(editor, item, startLine)
             }
+            this.sessionManager.incrementSuggestionCount()
         }
         commands.registerCommand('aws.amazonq.acceptInline', onInlineAcceptance)
 
@@ -145,6 +173,7 @@ export class InlineCompletionManager implements Disposable {
                     this.languageClient,
                     this.recommendationService,
                     this.sessionManager,
+                    this.inlineTutorialAnnotation,
                     false
                 )
             )
@@ -170,52 +199,91 @@ export class AmazonQInlineCompletionItemProvider implements InlineCompletionItem
         private readonly languageClient: LanguageClient,
         private readonly recommendationService: RecommendationService,
         private readonly sessionManager: SessionManager,
+        private readonly inlineTutorialAnnotation: InlineTutorialAnnotation,
         private readonly isNewSession: boolean = true
     ) {}
 
-    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
-            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,
-                ],
+    ): Promise<InlineCompletionItem[]> {
+        try {
+            vsCodeState.isRecommendationsActive = true
+            if (this.isNewSession) {
+                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)
+
+                // make service requests if it's a new session
+                await this.recommendationService.getAllRecommendations(
+                    this.languageClient,
+                    document,
+                    position,
+                    context,
+                    token
+                )
             }
-            ReferenceInlineProvider.instance.setInlineReference(
-                position.line,
-                item.insertText as string,
-                item.references
-            )
-            ImportAdderProvider.instance.onShowRecommendation(document, position.line, item)
+            // 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)
+            }
+
+            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
+                ReferenceInlineProvider.instance.setInlineReference(
+                    cursorPosition.line,
+                    item.insertText,
+                    item.references
+                )
+                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[]
     }
 }