Merge master into feature/hybridChat-local

Author: aws-toolkit-automation

package-lock.json

@@ -0,0 +1,4 @@
+{
+	"type": "Feature",
+	"description": "Agentic coding experience: Amazon Q can now write code and run shell commands on your behalf"
+}

packages/amazonq/.changes/next-release/Feature-ef539952-41de-40d0-870e-94aee31f36d3.json

@@ -18,7 +18,7 @@ export async function activate(context: ExtensionContext) {
         void amazonq.LspController.instance.trySetupLsp(context, {
             startUrl: AuthUtil.instance.startUrl,
             maxIndexSize: CodeWhispererSettings.instance.getMaxIndexSize(),
-            isVectorIndexEnabled: CodeWhispererSettings.instance.isLocalIndexEnabled(),
+            isVectorIndexEnabled: false,
         })
     }, 5000)
 
@@ -30,14 +30,7 @@ export async function activate(context: ExtensionContext) {
         amazonq.listCodeWhispererCommandsWalkthrough.register(),
         amazonq.focusAmazonQPanel.register(),
         amazonq.focusAmazonQPanelKeybinding.register(),
-        amazonq.tryChatCodeLensCommand.register(),
-        vscode.workspace.onDidChangeConfiguration(async (configurationChangeEvent) => {
-            if (configurationChangeEvent.affectsConfiguration('amazonQ.workspaceIndex')) {
-                if (CodeWhispererSettings.instance.isLocalIndexEnabled()) {
-                    void setupLsp()
-                }
-            }
-        })
+        amazonq.tryChatCodeLensCommand.register()
     )
 
     Commands.register('aws.amazonq.learnMore', () => {

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

@@ -66,20 +66,29 @@ export const notificationTypes = {
  * Facade over our VSCode Auth that does crud operations on the language server auth
  */
 export class AmazonQLspAuth {
-    constructor(private readonly client: LanguageClient) {}
+    #logErrorIfChanged = onceChanged((s) => getLogger('amazonqLsp').error(s))
+    constructor(
+        private readonly client: LanguageClient,
+        private readonly authUtil: AuthUtil = AuthUtil.instance
+    ) {}
 
     /**
      * @param force bypass memoization, and forcefully update the bearer token
      */
     async refreshConnection(force: boolean = false) {
-        const activeConnection = AuthUtil.instance.auth.activeConnection
-        if (activeConnection?.type === 'sso') {
+        const activeConnection = this.authUtil.auth.activeConnection
+        if (activeConnection?.state === 'valid' && activeConnection?.type === 'sso') {
             // send the token to the language server
-            const token = await AuthUtil.instance.getBearerToken()
+            const token = await this.authUtil.getBearerToken()
             await (force ? this._updateBearerToken(token) : this.updateBearerToken(token))
         }
     }
 
+    async logRefreshError(e: unknown) {
+        const err = e as Error
+        this.#logErrorIfChanged(`Unable to update bearer token: ${err.name}:${err.message}`)
+    }
+
     public updateBearerToken = onceChanged(this._updateBearerToken.bind(this))
     private async _updateBearerToken(token: string) {
         const request = await this.createUpdateCredentialsRequest({
@@ -93,10 +102,7 @@ export class AmazonQLspAuth {
 
     public startTokenRefreshInterval(pollingTime: number = oneMinute / 2) {
         const interval = setInterval(async () => {
-            await this.refreshConnection().catch((e) => {
-                getLogger('amazonqLsp').error('Unable to update bearer token: %s', (e as Error).message)
-                clearInterval(interval)
-            })
+            await this.refreshConnection().catch((e) => this.logRefreshError(e))
         }, pollingTime)
         return interval
     }

packages/amazonq/src/lsp/auth.ts

@@ -85,6 +85,12 @@ export async function activate(languageClient: LanguageClient, encryptionKey: Bu
                 type: 'customization',
                 customization: undefinedIfEmpty(getSelectedCustomization().arn),
             })
+        }),
+        globals.logOutputChannel.onDidChangeLogLevel((logLevel) => {
+            getLogger('amazonqLsp').info(`Local log level changed to ${logLevel}, notifying LSP`)
+            void pushConfigUpdate(languageClient, {
+                type: 'logLevel',
+            })
         })
     )
 }
@@ -98,16 +104,24 @@ export async function activate(languageClient: LanguageClient, encryptionKey: Bu
  * push the given config.
  */
 async function pushConfigUpdate(client: LanguageClient, config: QConfigs) {
-    if (config.type === 'profile') {
-        await client.sendRequest(updateConfigurationRequestType.method, {
-            section: 'aws.q',
-            settings: { profileArn: config.profileArn },
-        })
-    } else if (config.type === 'customization') {
-        client.sendNotification(DidChangeConfigurationNotification.type.method, {
-            section: 'aws.q',
-            settings: { customization: config.customization },
-        })
+    switch (config.type) {
+        case 'profile':
+            await client.sendRequest(updateConfigurationRequestType.method, {
+                section: 'aws.q',
+                settings: { profileArn: config.profileArn },
+            })
+            break
+        case 'customization':
+            client.sendNotification(DidChangeConfigurationNotification.type.method, {
+                section: 'aws.q',
+                settings: { customization: config.customization },
+            })
+            break
+        case 'logLevel':
+            client.sendNotification(DidChangeConfigurationNotification.type.method, {
+                section: 'aws.logLevel',
+            })
+            break
     }
 }
 type ProfileConfig = {
@@ -118,4 +132,7 @@ type CustomizationConfig = {
     type: 'customization'
     customization: string | undefined
 }
-type QConfigs = ProfileConfig | CustomizationConfig
+type LogLevelConfig = {
+    type: 'logLevel'
+}
+type QConfigs = ProfileConfig | CustomizationConfig | LogLevelConfig

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

@@ -6,6 +6,9 @@
 import { Commands, globals } from 'aws-core-vscode/shared'
 import { window } from 'vscode'
 import { AmazonQChatViewProvider } from './webviewProvider'
+import { CodeScanIssue } from 'aws-core-vscode/codewhisperer'
+import { EditorContextExtractor } from 'aws-core-vscode/codewhispererChat'
+import { DefaultAmazonQAppInitContext } from 'aws-core-vscode/amazonq'
 
 /**
  * TODO: Re-enable these once we can figure out which path they're going to live in
@@ -17,6 +20,52 @@ export function registerCommands(provider: AmazonQChatViewProvider) {
         registerGenericCommand('aws.amazonq.refactorCode', 'Refactor', provider),
         registerGenericCommand('aws.amazonq.fixCode', 'Fix', provider),
         registerGenericCommand('aws.amazonq.optimizeCode', 'Optimize', provider),
+        Commands.register('aws.amazonq.generateUnitTests', async () => {
+            DefaultAmazonQAppInitContext.instance.getAppsToWebViewMessagePublisher().publish({
+                sender: 'testChat',
+                command: 'test',
+                type: 'chatMessage',
+            })
+        }),
+        Commands.register('aws.amazonq.explainIssue', async (issue: CodeScanIssue) => {
+            void focusAmazonQPanel().then(async () => {
+                const editorContextExtractor = new EditorContextExtractor()
+                const extractedContext = await editorContextExtractor.extractContextForTrigger('ContextMenu')
+                const selectedCode =
+                    extractedContext?.activeFileContext?.fileText
+                        ?.split('\n')
+                        .slice(issue.startLine, issue.endLine)
+                        .join('\n') ?? ''
+
+                // The message that gets sent to the UI
+                const uiMessage = [
+                    'Explain the ',
+                    issue.title,
+                    ' issue in the following code:',
+                    '\n```\n',
+                    selectedCode,
+                    '\n```',
+                ].join('')
+
+                // The message that gets sent to the backend
+                const contextMessage = `Explain the issue "${issue.title}" (${JSON.stringify(
+                    issue
+                )}) and generate code demonstrating the fix`
+
+                void provider.webview?.postMessage({
+                    command: 'sendToPrompt',
+                    params: {
+                        selection: '',
+                        triggerType: 'contextMenu',
+                        prompt: {
+                            prompt: uiMessage, // what gets sent to the user
+                            escapedPrompt: contextMessage, // what gets sent to the backend
+                        },
+                        autoSubmit: true,
+                    },
+                })
+            })
+        }),
         Commands.register('aws.amazonq.sendToPrompt', (data) => {
             const triggerType = getCommandTriggerType(data)
             const selection = getSelectedText()

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

@@ -57,9 +57,15 @@ import * as vscode from 'vscode'
 import { Disposable, LanguageClient, Position, TextDocumentIdentifier } from 'vscode-languageclient'
 import * as jose from 'jose'
 import { AmazonQChatViewProvider } from './webviewProvider'
-import { AuthUtil } from 'aws-core-vscode/codewhisperer'
+import { AuthUtil, ReferenceLogViewProvider } from 'aws-core-vscode/codewhisperer'
 import { amazonQDiffScheme, AmazonQPromptSettings, messages, openUrl } from 'aws-core-vscode/shared'
-import { DefaultAmazonQAppInitContext, messageDispatcher, EditorContentController } from 'aws-core-vscode/amazonq'
+import {
+    DefaultAmazonQAppInitContext,
+    messageDispatcher,
+    EditorContentController,
+    ViewDiffMessage,
+    referenceLogText,
+} from 'aws-core-vscode/amazonq'
 import { telemetry, TelemetryBase } from 'aws-core-vscode/telemetry'
 import { isValidResponseError } from './error'
 
@@ -449,17 +455,24 @@ export function registerMessageListeners(
             new vscode.Position(0, 0),
             new vscode.Position(doc.lineCount - 1, doc.lineAt(doc.lineCount - 1).text.length)
         )
-        await ecc.viewDiff(
-            {
-                context: {
-                    activeFileContext: { filePath: params.originalFileUri },
-                    focusAreaContext: { selectionInsideExtendedCodeBlock: entireDocumentSelection },
+        const viewDiffMessage: ViewDiffMessage = {
+            context: {
+                activeFileContext: {
+                    filePath: params.originalFileUri,
+                    fileText: params.originalFileContent ?? '',
+                    fileLanguage: undefined,
+                    matchPolicy: undefined,
+                },
+                focusAreaContext: {
+                    selectionInsideExtendedCodeBlock: entireDocumentSelection,
+                    codeBlock: '',
+                    extendedCodeBlock: '',
+                    names: undefined,
                 },
-                code: params.fileContent ?? '',
             },
-            amazonQDiffScheme,
-            true
-        )
+            code: params.fileContent ?? '',
+        }
+        await ecc.viewDiff(viewDiffMessage, amazonQDiffScheme)
     })
 
     languageClient.onNotification(chatUpdateNotificationType.method, (params: ChatUpdateParams) => {
@@ -525,20 +538,25 @@ async function handlePartialResult<T extends ChatResult>(
  * Decodes the final chat responses from the language server before sending it to mynah UI.
  * Once this is called the answer response is finished
  */
-async function handleCompleteResult<T>(
+async function handleCompleteResult<T extends ChatResult>(
     result: string | T,
     encryptionKey: Buffer | undefined,
     provider: AmazonQChatViewProvider,
     tabId: string,
     disposable: Disposable
 ) {
     const decryptedMessage =
-        typeof result === 'string' && encryptionKey ? await decodeRequest(result, encryptionKey) : result
+        typeof result === 'string' && encryptionKey ? await decodeRequest<T>(result, encryptionKey) : (result as T)
     void provider.webview?.postMessage({
         command: chatRequestType.method,
         params: decryptedMessage,
         tabId: tabId,
     })
+
+    // only add the reference log once the request is complete, otherwise we will get duplicate log items
+    for (const ref of decryptedMessage.codeReference ?? []) {
+        ReferenceLogViewProvider.instance.addReferenceLog(referenceLogText(ref))
+    }
     disposable.dispose()
 }
 

packages/amazonq/src/lsp/chat/messages.ts

@@ -139,7 +139,7 @@ export class AmazonQChatViewProvider implements WebviewViewProvider {
                     const vscodeApi = acquireVsCodeApi()
                     const hybridChatConnector = new HybridChatAdapter(${(await AuthUtil.instance.getChatAuthState()).amazonQ === 'connected'},${featureConfigData},${welcomeCount},${disclaimerAcknowledged},${regionProfileString},${disabledCommands},${isSMUS},${isSM},vscodeApi.postMessage)
                     const commands = [hybridChatConnector.initialQuickActions[0]]
-                    qChat = amazonQChat.createChat(vscodeApi, {disclaimerAcknowledged: ${disclaimerAcknowledged}, pairProgrammingAcknowledged: ${pairProgrammingAcknowledged}, quickActionCommands: commands}, hybridChatConnector, ${JSON.stringify(featureConfigData)});
+                    qChat = amazonQChat.createChat(vscodeApi, {disclaimerAcknowledged: ${disclaimerAcknowledged}, pairProgrammingAcknowledged: ${pairProgrammingAcknowledged}, agenticMode: true, quickActionCommands: commands}, hybridChatConnector, ${JSON.stringify(featureConfigData)});
                 }
                 window.addEventListener('message', (event) => {
                     /**