Merge branch 'master' into feature/agent-migration

Author: laileni-aws

package-lock.json

@@ -74,7 +74,7 @@
         "webpack-merge": "^5.10.0"
     },
     "dependencies": {
-        "@aws/language-server-runtimes": "^0.2.125",
+        "@aws/language-server-runtimes": "^0.2.128",
         "@types/node": "^22.7.5",
         "jaro-winkler": "^0.2.8",
         "vscode-nls": "^5.2.0",

package.json

@@ -0,0 +1,5 @@
+{
+	"date": "2025-09-11",
+	"version": "1.94.0",
+	"entries": []
+}

packages/amazonq/.changes/1.94.0.json

@@ -1,3 +1,7 @@
+## 1.94.0 2025-09-11
+
+- Miscellaneous non-user-facing changes
+
 ## 1.93.0 2025-09-05
 
 - Miscellaneous non-user-facing changes

packages/amazonq/CHANGELOG.md

@@ -2,7 +2,7 @@
     "name": "amazon-q-vscode",
     "displayName": "Amazon Q",
     "description": "The most capable generative AI–powered assistant for software development.",
-    "version": "1.94.0-SNAPSHOT",
+    "version": "1.95.0-SNAPSHOT",
     "extensionKind": [
         "workspace"
     ],

packages/amazonq/package.json

@@ -5,29 +5,73 @@
 
 import vscode from 'vscode'
 import {
+    acceptSuggestion,
     AuthUtil,
+    CodeSuggestionsState,
+    CodeWhispererCodeCoverageTracker,
     CodeWhispererConstants,
+    CodeWhispererSettings,
+    ConfigurationEntry,
+    DefaultCodeWhispererClient,
+    invokeRecommendation,
     isInlineCompletionEnabled,
+    KeyStrokeHandler,
+    RecommendationHandler,
     runtimeLanguageContext,
+    TelemetryHelper,
     UserWrittenCodeTracker,
     vsCodeState,
 } from 'aws-core-vscode/codewhisperer'
-import { globals, sleep } from 'aws-core-vscode/shared'
+import { Commands, getLogger, globals, sleep } from 'aws-core-vscode/shared'
+import { LanguageClient } from 'vscode-languageclient'
 
-export async function activate() {
-    if (isInlineCompletionEnabled()) {
-        // Debugging purpose: only initialize NextEditPredictionPanel when development
-        // NextEditPredictionPanel.getInstance()
+export async function activate(languageClient: LanguageClient) {
+    const codewhispererSettings = CodeWhispererSettings.instance
+    const client = new DefaultCodeWhispererClient()
 
+    if (isInlineCompletionEnabled()) {
         await setSubscriptionsforInlineCompletion()
         await AuthUtil.instance.setVscodeContextProps()
+        RecommendationHandler.instance.setLanguageClient(languageClient)
+    }
+
+    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(
+            acceptSuggestion.register(globals.context),
+            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) {
@@ -40,6 +84,7 @@ export async function activate() {
                     return
                 }
 
+                CodeWhispererCodeCoverageTracker.getTracker(e.document.languageId)?.countTotalTokens(e)
                 UserWrittenCodeTracker.instance.onTextDocumentChange(e)
                 /**
                  * Handle this keystroke event only when
@@ -51,6 +96,11 @@ export async function activate() {
                     return
                 }
 
+                if (vsCodeState.lastUserModificationTime) {
+                    TelemetryHelper.instance.setTimeSinceLastModification(
+                        performance.now() - vsCodeState.lastUserModificationTime
+                    )
+                }
                 vsCodeState.lastUserModificationTime = performance.now()
                 /**
                  * Important:  Doing this sleep(10) is to make sure
@@ -59,6 +109,19 @@ 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: Error) => {
+                    getLogger().error('invokeRecommendation failed: %s', (e as Error).message)
+                })
             })
         )
     }

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

@@ -6,6 +6,7 @@
 import * as vscode from 'vscode'
 import { Commands, getLogger, messages } from 'aws-core-vscode/shared'
 import { AutoDebugController } from './controller'
+import { autoDebugTelemetry } from './telemetry'
 
 /**
  * Auto Debug commands for Amazon Q
@@ -72,6 +73,16 @@ export class AutoDebugCommands implements vscode.Disposable {
             return await action()
         } catch (error) {
             this.logger.error(`AutoDebugCommands: Error in ${logContext}: %s`, error)
+
+            // Record telemetry failure based on context
+            const commandType =
+                logContext === 'fixWithAmazonQ'
+                    ? 'fixWithQ'
+                    : logContext === 'fixAllWithAmazonQ'
+                      ? 'fixAllWithQ'
+                      : 'explainProblem'
+            autoDebugTelemetry.recordCommandFailure(commandType, String(error))
+
             void messages.showMessage('error', 'Amazon Q was not able to fix or explain the problem. Try again shortly')
         }
     }
@@ -91,13 +102,21 @@ export class AutoDebugCommands implements vscode.Disposable {
      * Fix with Amazon Q - fixes only the specific issues the user selected
      */
     private async fixWithAmazonQ(range?: vscode.Range, diagnostics?: vscode.Diagnostic[]): Promise<void> {
+        const problemCount = diagnostics?.length
+        autoDebugTelemetry.recordCommandInvocation('fixWithQ', problemCount)
+
         await this.executeWithErrorHandling(
             async () => {
                 const editor = this.checkActiveEditor()
                 if (!editor) {
                     return
                 }
+                const saved = await editor.document.save()
+                if (!saved) {
+                    throw new Error('Failed to save document')
+                }
                 await this.controller.fixSpecificProblems(range, diagnostics)
+                autoDebugTelemetry.recordCommandSuccess('fixWithQ', problemCount)
             },
             'Fix with Amazon Q',
             'fixWithAmazonQ'
@@ -108,13 +127,20 @@ export class AutoDebugCommands implements vscode.Disposable {
      * Fix All with Amazon Q - processes all errors in the current file
      */
     private async fixAllWithAmazonQ(): Promise<void> {
+        autoDebugTelemetry.recordCommandInvocation('fixAllWithQ')
+
         await this.executeWithErrorHandling(
             async () => {
                 const editor = this.checkActiveEditor()
                 if (!editor) {
                     return
                 }
-                await this.controller.fixAllProblemsInFile(10) // 10 errors per batch
+                const saved = await editor.document.save()
+                if (!saved) {
+                    throw new Error('Failed to save document')
+                }
+                const problemCount = await this.controller.fixAllProblemsInFile(10) // 10 errors per batch
+                autoDebugTelemetry.recordCommandSuccess('fixAllWithQ', problemCount)
             },
             'Fix All with Amazon Q',
             'fixAllWithAmazonQ'
@@ -125,13 +151,17 @@ export class AutoDebugCommands implements vscode.Disposable {
      * Explains the problem using Amazon Q
      */
     private async explainProblem(range?: vscode.Range, diagnostics?: vscode.Diagnostic[]): Promise<void> {
+        const problemCount = diagnostics?.length
+        autoDebugTelemetry.recordCommandInvocation('explainProblem', problemCount)
+
         await this.executeWithErrorHandling(
             async () => {
                 const editor = this.checkActiveEditor()
                 if (!editor) {
                     return
                 }
                 await this.controller.explainProblems(range, diagnostics)
+                autoDebugTelemetry.recordCommandSuccess('explainProblem', problemCount)
             },
             'Explain Problem',
             'explainProblem'

packages/amazonq/src/lsp/chat/autoDebug/commands.ts

@@ -110,32 +110,34 @@ export class AutoDebugController implements vscode.Disposable {
     /**
      * Fix with Amazon Q - sends up to 15 error messages one time when user clicks the button
      */
-    public async fixAllProblemsInFile(maxProblems: number = 15): Promise<void> {
+    public async fixAllProblemsInFile(maxProblems: number = 15): Promise<number> {
         try {
             const editor = vscode.window.activeTextEditor
             if (!editor) {
                 void messages.showMessage('warn', 'No active editor found')
-                return
+                return 0
             }
 
             // Get all diagnostics for the current file
             const allDiagnostics = vscode.languages.getDiagnostics(editor.document.uri)
             const errorDiagnostics = this.filterErrorDiagnostics(allDiagnostics)
             if (errorDiagnostics.length === 0) {
-                return
+                return 0
             }
 
             // Take up to maxProblems errors (15 by default)
             const diagnosticsToFix = errorDiagnostics.slice(0, maxProblems)
             const result = await this.getProblemsFromDiagnostics(undefined, diagnosticsToFix)
             if (!result) {
-                return
+                return 0
             }
 
             const fixMessage = this.createFixMessage(result.editor.document.uri.fsPath, result.problems)
             await this.sendMessageToChat(fixMessage)
+            return result.problems.length
         } catch (error) {
             this.logger.error('AutoDebugController: Error in fix process: %s', error)
+            throw error
         }
     }
 

packages/amazonq/src/lsp/chat/autoDebug/controller.ts

@@ -0,0 +1,71 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { telemetry } from 'aws-core-vscode/telemetry'
+
+/**
+ * Auto Debug command types for telemetry tracking
+ */
+export type AutoDebugCommandType = 'fixWithQ' | 'fixAllWithQ' | 'explainProblem'
+
+/**
+ * Telemetry interface for Auto Debug feature
+ * Tracks usage counts and success rates for the three main commands
+ */
+export interface AutoDebugTelemetry {
+    /**
+     * Record when an auto debug command is invoked
+     */
+    recordCommandInvocation(commandType: AutoDebugCommandType, problemCount?: number): void
+
+    /**
+     * Record when an auto debug command succeeds
+     */
+    recordCommandSuccess(commandType: AutoDebugCommandType, problemCount?: number): void
+
+    /**
+     * Record when an auto debug command fails
+     */
+    recordCommandFailure(commandType: AutoDebugCommandType, error?: string, problemCount?: number): void
+}
+
+/**
+ * Implementation of Auto Debug telemetry tracking
+ */
+export class AutoDebugTelemetryImpl implements AutoDebugTelemetry {
+    recordCommandInvocation(commandType: AutoDebugCommandType, problemCount?: number): void {
+        telemetry.amazonq_autoDebugCommand.emit({
+            amazonqAutoDebugCommandType: commandType,
+            amazonqAutoDebugAction: 'invoked',
+            amazonqAutoDebugProblemCount: problemCount,
+            result: 'Succeeded',
+        })
+    }
+
+    recordCommandSuccess(commandType: AutoDebugCommandType, problemCount?: number): void {
+        telemetry.amazonq_autoDebugCommand.emit({
+            amazonqAutoDebugCommandType: commandType,
+            amazonqAutoDebugAction: 'completed',
+            amazonqAutoDebugProblemCount: problemCount,
+            result: 'Succeeded',
+        })
+    }
+
+    recordCommandFailure(commandType: AutoDebugCommandType, error?: string, problemCount?: number): void {
+        telemetry.amazonq_autoDebugCommand.emit({
+            amazonqAutoDebugCommandType: commandType,
+            amazonqAutoDebugAction: 'completed',
+            amazonqAutoDebugProblemCount: problemCount,
+            result: 'Failed',
+            reason: error ? 'Error' : 'Unknown',
+            reasonDesc: error?.substring(0, 200), // Truncate to 200 chars as recommended
+        })
+    }
+}
+
+/**
+ * Global instance of auto debug telemetry
+ */
+export const autoDebugTelemetry: AutoDebugTelemetry = new AutoDebugTelemetryImpl()