Merge branch 'feature/code-diff' into feature/StreamingDiffAnimation

Author: laileni-aws

package-lock.json

@@ -0,0 +1,4 @@
+{
+	"type": "Feature",
+	"description": "/transform: Show transformation history in Transformation Hub and allow users to resume jobs"
+}

packages/amazonq/.changes/next-release/Feature-dffec708-ae10-45d7-bcfd-b1c07a84de12.json

@@ -746,7 +746,7 @@
             },
             {
                 "command": "aws.amazonq.showHistoryInHub",
-                "title": "%AWS.command.q.transform.viewJobStatus%"
+                "title": "%AWS.command.q.transform.viewJobHistory%"
             },
             {
                 "command": "aws.amazonq.selectCustomization",

packages/amazonq/package.json

@@ -352,6 +352,8 @@ export async function displaySvgDecoration(
                         discarded: false,
                     },
                 },
+                totalSessionDisplayTime: Date.now() - session.requestStartTime,
+                firstCompletionDisplayLatency: session.firstCompletionDisplayLatency,
                 isInlineEdit: true,
             }
             languageClient.sendNotification('aws/logInlineCompletionSessionResults', params)

packages/amazonq/src/app/inline/EditRendering/displayImage.ts

@@ -170,10 +170,11 @@ export class InlineCompletionManager implements Disposable {
         const onInlineRejection = async () => {
             try {
                 vsCodeState.isCodeWhispererEditing = true
-                if (this.sessionManager.getActiveSession() === undefined) {
+                const session = this.sessionManager.getActiveSession()
+                if (session === undefined) {
                     return
                 }
-                const requestStartTime = this.sessionManager.getActiveSession()!.requestStartTime
+                const requestStartTime = session.requestStartTime
                 const totalSessionDisplayTime = performance.now() - requestStartTime
                 await commands.executeCommand('editor.action.inlineSuggest.hide')
                 // TODO: also log the seen state for other suggestions in session
@@ -182,9 +183,9 @@ export class InlineCompletionManager implements Disposable {
                     CodeWhispererConstants.platformLanguageIds,
                     this.inlineCompletionProvider
                 )
-                const sessionId = this.sessionManager.getActiveSession()?.sessionId
+                const sessionId = session.sessionId
                 const itemId = this.sessionManager.getActiveRecommendation()[0]?.itemId
-                if (!sessionId || !itemId) {
+                if (!itemId) {
                     return
                 }
                 const params: LogInlineCompletionSessionResultsParams = {
@@ -196,6 +197,7 @@ export class InlineCompletionManager implements Disposable {
                             discarded: false,
                         },
                     },
+                    firstCompletionDisplayLatency: session.firstCompletionDisplayLatency,
                     totalSessionDisplayTime: totalSessionDisplayTime,
                 }
                 this.languageClient.sendNotification(this.logSessionResultMessageName, params)
@@ -290,14 +292,16 @@ export class AmazonQInlineCompletionItemProvider implements InlineCompletionItem
             const prevSessionId = prevSession?.sessionId
             const prevItemId = this.sessionManager.getActiveRecommendation()?.[0]?.itemId
             const prevStartPosition = prevSession?.startPosition
-            if (prevSession?.triggerOnAcceptance) {
+            const editsTriggerOnAcceptance = prevSession?.triggerOnAcceptance
+            if (editsTriggerOnAcceptance) {
                 getAllRecommendationsOptions = {
                     ...getAllRecommendationsOptions,
                     editsStreakToken: prevSession?.editsStreakPartialResultToken,
                 }
             }
             const editor = window.activeTextEditor
-            if (prevSession && prevSessionId && prevItemId && prevStartPosition) {
+            // Skip prefix matching for Edits suggestions that trigger on acceptance.
+            if (prevSession && prevSessionId && prevItemId && prevStartPosition && !editsTriggerOnAcceptance) {
                 const prefix = document.getText(new Range(prevStartPosition, position))
                 const prevItemMatchingPrefix = []
                 for (const item of this.sessionManager.getActiveRecommendation()) {
@@ -341,6 +345,7 @@ export class AmazonQInlineCompletionItemProvider implements InlineCompletionItem
                             discarded: !prevSession.displayed,
                         },
                     },
+                    firstCompletionDisplayLatency: prevSession.firstCompletionDisplayLatency,
                     totalSessionDisplayTime: performance.now() - prevSession.requestStartTime,
                 }
                 this.languageClient.sendNotification(this.logSessionResultMessageName, params)

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

@@ -21,6 +21,7 @@ import {
 import { TelemetryHelper } from './telemetryHelper'
 import { ICursorUpdateRecorder } from './cursorUpdateManager'
 import { getLogger } from 'aws-core-vscode/shared'
+import { getOpenFilesInWindow } from 'aws-core-vscode/utils'
 import { asyncCallWithTimeout } from '../../util/timeoutUtil'
 
 export interface GetAllRecommendationsOptions {
@@ -79,14 +80,15 @@ export class RecommendationService {
                   contentChanges: documentChangeEvent.contentChanges.map((x) => x as TextDocumentContentChangeEvent),
               }
             : undefined
-
+        const openTabs = await getOpenFilesInWindow()
         let request: InlineCompletionWithReferencesParams = {
             textDocument: {
                 uri: document.uri.toString(),
             },
             position,
             context,
             documentChangeParams: documentChangeParams,
+            openTabFilepaths: openTabs,
         }
         if (options.editsStreakToken) {
             request = { ...request, partialResultToken: options.editsStreakToken }

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

@@ -45,6 +45,7 @@ import { registerCommands } from './commands'
 import { focusAmazonQPanel } from 'aws-core-vscode/codewhispererChat'
 import { activate as activateAmazonqLsp } from './lsp/activation'
 import { hasGlibcPatch } from './lsp/client'
+import { activateAutoDebug } from './lsp/chat/autoDebug/activation'
 
 export const amazonQContextPrefix = 'amazonq'
 
@@ -131,6 +132,14 @@ export async function activateAmazonQCommon(context: vscode.ExtensionContext, is
         await activateAmazonqLsp(context)
     }
 
+    // Activate AutoDebug feature at extension level
+    try {
+        const autoDebugFeature = await activateAutoDebug(context)
+        context.subscriptions.push(autoDebugFeature)
+    } catch (error) {
+        getLogger().error('Failed to activate AutoDebug feature at extension level: %s', error)
+    }
+
     // Generic extension commands
     registerGenericCommands(context, amazonQContextPrefix)
 

packages/amazonq/src/extension.ts

@@ -17,12 +17,16 @@ import { activate as registerLegacyChatListeners } from '../../app/chat/activati
 import { DefaultAmazonQAppInitContext } from 'aws-core-vscode/amazonq'
 import { AuthUtil, getSelectedCustomization } from 'aws-core-vscode/codewhisperer'
 import { pushConfigUpdate } from '../config'
+import { AutoDebugLspClient } from './autoDebug/lsp/autoDebugLspClient'
 
 export async function activate(languageClient: LanguageClient, encryptionKey: Buffer, mynahUIPath: string) {
     const disposables = globals.context.subscriptions
 
     const provider = new AmazonQChatViewProvider(mynahUIPath, languageClient)
 
+    // Set the chat view provider for AutoDebug to use
+    AutoDebugLspClient.setChatViewProvider(provider)
+
     disposables.push(
         window.registerWebviewViewProvider(AmazonQChatViewProvider.viewType, provider, {
             webviewOptions: {

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

@@ -0,0 +1,78 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode'
+import { getLogger } from 'aws-core-vscode/shared'
+import { AutoDebugCommands } from './commands'
+import { AutoDebugCodeActionsProvider } from './codeActionsProvider'
+import { AutoDebugController } from './controller'
+
+/**
+ * Auto Debug feature activation for Amazon Q
+ * This handles the complete lifecycle of the auto debug feature
+ */
+export class AutoDebugFeature implements vscode.Disposable {
+    private readonly logger = getLogger()
+    private readonly disposables: vscode.Disposable[] = []
+
+    private autoDebugCommands?: AutoDebugCommands
+    private codeActionsProvider?: AutoDebugCodeActionsProvider
+    private controller?: AutoDebugController
+
+    constructor(private readonly context: vscode.ExtensionContext) {}
+
+    /**
+     * Activate the auto debug feature
+     */
+    async activate(): Promise<void> {
+        try {
+            // Initialize the controller first
+            this.controller = new AutoDebugController()
+
+            // Initialize commands and register them with the controller
+            this.autoDebugCommands = new AutoDebugCommands()
+            this.autoDebugCommands.registerCommands(this.context, this.controller)
+
+            // Initialize code actions provider
+            this.codeActionsProvider = new AutoDebugCodeActionsProvider()
+            this.context.subscriptions.push(this.codeActionsProvider)
+
+            // Add all to disposables
+            this.disposables.push(this.controller, this.autoDebugCommands, this.codeActionsProvider)
+        } catch (error) {
+            this.logger.error('AutoDebugFeature: Failed to activate auto debug feature: %s', error)
+            throw error
+        }
+    }
+
+    /**
+     * Get the auto debug controller instance
+     */
+    getController(): AutoDebugController | undefined {
+        return this.controller
+    }
+
+    /**
+     * Dispose of all resources
+     */
+    dispose(): void {
+        vscode.Disposable.from(...this.disposables).dispose()
+    }
+}
+
+/**
+ * Factory function to activate auto debug feature with LSP client
+ * This is the main entry point for activating auto debug
+ */
+export async function activateAutoDebug(
+    context: vscode.ExtensionContext,
+    client?: any,
+    encryptionKey?: Buffer
+): Promise<AutoDebugFeature> {
+    const feature = new AutoDebugFeature(context)
+    await feature.activate()
+
+    return feature
+}

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

@@ -0,0 +1,119 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode'
+
+/**
+ * Provides code actions for Amazon Q Auto Debug features.
+ * Integrates with VS Code's quick fix system to offer debugging assistance.
+ */
+export class AutoDebugCodeActionsProvider implements vscode.CodeActionProvider, vscode.Disposable {
+    private readonly disposables: vscode.Disposable[] = []
+
+    public static readonly providedCodeActionKinds = [vscode.CodeActionKind.QuickFix, vscode.CodeActionKind.Refactor]
+
+    constructor() {
+        this.registerProvider()
+    }
+
+    private registerProvider(): void {
+        // Register for all file types
+        const selector: vscode.DocumentSelector = [{ scheme: 'file' }]
+
+        this.disposables.push(
+            vscode.languages.registerCodeActionsProvider(selector, this, {
+                providedCodeActionKinds: AutoDebugCodeActionsProvider.providedCodeActionKinds,
+            })
+        )
+    }
+
+    /**
+     * Provides code actions for the given document and range
+     */
+    public provideCodeActions(
+        document: vscode.TextDocument,
+        range: vscode.Range | vscode.Selection,
+        context: vscode.CodeActionContext,
+        token: vscode.CancellationToken
+    ): vscode.ProviderResult<(vscode.CodeAction | vscode.Command)[]> {
+        if (token.isCancellationRequested) {
+            return []
+        }
+
+        const actions: vscode.CodeAction[] = []
+
+        // Get diagnostics for the current range
+        const diagnostics = context.diagnostics.filter(
+            (diagnostic) => diagnostic.range.intersection(range) !== undefined
+        )
+
+        if (diagnostics.length > 0) {
+            // Add "Fix with Amazon Q" action
+            actions.push(this.createFixWithQAction(document, range, diagnostics))
+
+            // Add "Fix All with Amazon Q" action
+            actions.push(this.createFixAllWithQAction(document))
+
+            // Add "Explain Problem" action
+            actions.push(this.createExplainProblemAction(document, range, diagnostics))
+        }
+        return actions
+    }
+
+    private createFixWithQAction(
+        document: vscode.TextDocument,
+        range: vscode.Range,
+        diagnostics: vscode.Diagnostic[]
+    ): vscode.CodeAction {
+        const action = new vscode.CodeAction(
+            `Amazon Q: Fix Problem (${diagnostics.length} issue${diagnostics.length !== 1 ? 's' : ''})`,
+            vscode.CodeActionKind.QuickFix
+        )
+
+        action.command = {
+            command: 'amazonq.01.fixWithQ',
+            title: 'Amazon Q: Fix Problem',
+            arguments: [range, diagnostics],
+        }
+
+        action.diagnostics = diagnostics
+        action.isPreferred = true // Make this the preferred quick fix
+
+        return action
+    }
+
+    private createFixAllWithQAction(document: vscode.TextDocument): vscode.CodeAction {
+        const action = new vscode.CodeAction('Amazon Q: Fix All Errors', vscode.CodeActionKind.QuickFix)
+
+        action.command = {
+            command: 'amazonq.02.fixAllWithQ',
+            title: 'Amazon Q: Fix All Errors',
+        }
+
+        return action
+    }
+
+    private createExplainProblemAction(
+        document: vscode.TextDocument,
+        range: vscode.Range,
+        diagnostics: vscode.Diagnostic[]
+    ): vscode.CodeAction {
+        const action = new vscode.CodeAction('Amazon Q: Explain Problem', vscode.CodeActionKind.QuickFix)
+
+        action.command = {
+            command: 'amazonq.03.explainProblem',
+            title: 'Amazon Q: Explain Problem',
+            arguments: [range, diagnostics],
+        }
+
+        action.diagnostics = diagnostics
+
+        return action
+    }
+
+    public dispose(): void {
+        vscode.Disposable.from(...this.disposables).dispose()
+    }
+}