feat(amazonq): Auto Debug Functionality (#7609)

## Problem
Developers frequently encounter compilation errors, linting issues, and
other diagnostic problems while coding in VS Code. Currently, they need
to manually copy error messages and switch to Amazon Q chat to get help
fixing these issues, creating friction in the development workflow and
breaking their coding flow.

## Solution
This PR introduces Amazon Q Auto Debug, a new feature that seamlessly
integrates diagnostic problem-solving directly into the VS Code editor
experience. The feature provides three main interaction methods:

Quick Fix Integration: When hovering over diagnostic errors/warnings,
developers see Amazon Q options in the quick fix menu including "Fix
Problem", "Fix All Errors", and "Explain Problem" actions.

Command Palette Access: Three new commands are registered
(amazonq.01.fixWithQ, amazonq.02.fixAllWithQ, amazonq.03.explainProblem)
that can be triggered from the command palette or bound to keyboard
shortcuts.

Intelligent Error Processing: The system automatically captures
diagnostic information from VS Code's language servers, formats error
context with surrounding code snippets, and sends structured prompts to
Amazon Q chat. For "Fix All" operations, it processes up to 15 errors at
once to avoid overwhelming the AI system.

The workflow operates through a controller-based architecture that
monitors VS Code diagnostics, formats error context with file paths and
line numbers, and communicates directly with the Amazon Q chat panel via
LSP client messaging. When users trigger a fix action, the system
automatically focuses the Amazon Q panel and submits a formatted prompt
containing the error details and surrounding code context, enabling
Amazon Q to provide targeted solutions without requiring manual context
switching.

## Video Demos
Fix single problem


https://github.com/user-attachments/assets/c73b7a63-8806-4016-b7af-03f239f07bba

Explain single problem



https://github.com/user-attachments/assets/367137aa-8362-4a08-a12b-27d892c0b6e6

Fix all errors



https://github.com/user-attachments/assets/95eb5691-d3be-499a-8e8c-76f4b77c57dd

---------

Co-authored-by: aws-toolkit-automation <[email protected]>
Co-authored-by: aws-toolkit-automation <>
Co-authored-by: Will Lo <[email protected]>
Co-authored-by: Diler Zaza <[email protected]>
Co-authored-by: Diler Zaza <[email protected]>
Co-authored-by: David <[email protected]>
Co-authored-by: David Hasani <[email protected]>
Co-authored-by: samgst-amazon <[email protected]>
Co-authored-by: Ashish Reddy Podduturi <[email protected]>
Co-authored-by: Tyrone Smith <[email protected]>
Co-authored-by: zelzhou <[email protected]>
Co-authored-by: Ralph Flora <[email protected]>
Co-authored-by: Jingyuan Li <[email protected]>
Co-authored-by: Rile Ge <[email protected]>
Co-authored-by: Aidan Ton <[email protected]>
Co-authored-by: Lei Gao <[email protected]>
Co-authored-by: Laxman Reddy <[email protected]>
Co-authored-by: invictus <[email protected]>
Co-authored-by: chungjac <[email protected]>

Author: 18 people

packages/amazonq/src/extension.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/lsp/chat/activation.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/autoDebug/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/codeActionsProvider.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()
+    }
+}

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

@@ -0,0 +1,147 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode'
+import { Commands, getLogger, messages } from 'aws-core-vscode/shared'
+import { AutoDebugController } from './controller'
+
+/**
+ * Auto Debug commands for Amazon Q
+ * Handles all command registrations and implementations
+ */
+export class AutoDebugCommands implements vscode.Disposable {
+    private readonly logger = getLogger()
+    private readonly disposables: vscode.Disposable[] = []
+    private controller!: AutoDebugController
+
+    /**
+     * Register all auto debug commands
+     */
+    registerCommands(context: vscode.ExtensionContext, controller: AutoDebugController): void {
+        this.controller = controller
+        this.disposables.push(
+            // Fix with Amazon Q command
+            Commands.register(
+                {
+                    id: 'amazonq.01.fixWithQ',
+                    name: 'Amazon Q: Fix Problem',
+                },
+                async (range?: vscode.Range, diagnostics?: vscode.Diagnostic[]) => {
+                    await this.fixWithAmazonQ(range, diagnostics)
+                }
+            ),
+
+            // Fix All with Amazon Q command
+            Commands.register(
+                {
+                    id: 'amazonq.02.fixAllWithQ',
+                    name: 'Amazon Q: Fix All Errors',
+                },
+                async () => {
+                    await this.fixAllWithAmazonQ()
+                }
+            ),
+
+            // Explain Problem with Amazon Q command
+            Commands.register(
+                {
+                    id: 'amazonq.03.explainProblem',
+                    name: 'Amazon Q: Explain Problem',
+                },
+                async (range?: vscode.Range, diagnostics?: vscode.Diagnostic[]) => {
+                    await this.explainProblem(range, diagnostics)
+                }
+            )
+        )
+
+        // Add all disposables to context
+        context.subscriptions.push(...this.disposables)
+    }
+
+    /**
+     * Generic error handling wrapper for command execution
+     */
+    private async executeWithErrorHandling<T>(
+        action: () => Promise<T>,
+        errorMessage: string,
+        logContext: string
+    ): Promise<T | void> {
+        try {
+            return await action()
+        } catch (error) {
+            this.logger.error(`AutoDebugCommands: Error in ${logContext}: %s`, error)
+            void messages.showMessage('error', 'Amazon Q was not able to fix or explain the problem. Try again shortly')
+        }
+    }
+
+    /**
+     * Check if there's an active editor and log warning if not
+     */
+    private checkActiveEditor(): vscode.TextEditor | undefined {
+        const editor = vscode.window.activeTextEditor
+        if (!editor) {
+            this.logger.warn('AutoDebugCommands: No active editor found')
+        }
+        return editor
+    }
+
+    /**
+     * Fix with Amazon Q - fixes only the specific issues the user selected
+     */
+    private async fixWithAmazonQ(range?: vscode.Range, diagnostics?: vscode.Diagnostic[]): Promise<void> {
+        await this.executeWithErrorHandling(
+            async () => {
+                const editor = this.checkActiveEditor()
+                if (!editor) {
+                    return
+                }
+                await this.controller.fixSpecificProblems(range, diagnostics)
+            },
+            'Fix with Amazon Q',
+            'fixWithAmazonQ'
+        )
+    }
+
+    /**
+     * Fix All with Amazon Q - processes all errors in the current file
+     */
+    private async fixAllWithAmazonQ(): Promise<void> {
+        await this.executeWithErrorHandling(
+            async () => {
+                const editor = this.checkActiveEditor()
+                if (!editor) {
+                    return
+                }
+                await this.controller.fixAllProblemsInFile(10) // 10 errors per batch
+            },
+            'Fix All with Amazon Q',
+            'fixAllWithAmazonQ'
+        )
+    }
+
+    /**
+     * Explains the problem using Amazon Q
+     */
+    private async explainProblem(range?: vscode.Range, diagnostics?: vscode.Diagnostic[]): Promise<void> {
+        await this.executeWithErrorHandling(
+            async () => {
+                const editor = this.checkActiveEditor()
+                if (!editor) {
+                    return
+                }
+                await this.controller.explainProblems(range, diagnostics)
+            },
+            'Explain Problem',
+            'explainProblem'
+        )
+    }
+
+    /**
+     * Dispose of all resources
+     */
+    dispose(): void {
+        vscode.Disposable.from(...this.disposables).dispose()
+    }
+}