feat(amazonq): Auto Debug Functionality

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/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/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/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/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()
+    }
+}