Amazon Q Transform Feature - human in the loop (#4920)

Allow users to interactively update dependencies while transformation is paused waiting for user input.

Author: damntrecky

package-lock.json

@@ -0,0 +1,4 @@
+{
+	"type": "Feature",
+	"description": "Transform: Add human intervention to help update dependencies during transformation."
+}

packages/amazonq/.changes/next-release/Feature-783a661b-705e-403f-af64-76db8c209496.json

@@ -3979,7 +3979,7 @@
     },
     "devDependencies": {
         "@aws-sdk/types": "^3.13.1",
-        "@aws-toolkits/telemetry": "^1.0.203",
+        "@aws-toolkits/telemetry": "^1.0.205",
         "@aws/fully-qualified-names": "^2.1.4",
         "@cspotcode/source-map-support": "^0.8.1",
         "@sinonjs/fake-timers": "^10.0.2",

packages/core/package.json

@@ -27,7 +27,7 @@ interface CopyTask {
 const tasks: CopyTask[] = [
     { target: path.join('src', 'templates') },
     { target: path.join('src', 'test', 'shared', 'cloudformation', 'yaml') },
-    { target: path.join('src', 'test', 'codewhisperer', 'service', 'resources') },
+    { target: path.join('src', 'test', 'amazonqGumby', 'resources') },
     { target: path.join('src', 'testFixtures') },
     { target: 'src/auth/sso/vue' },
 

packages/core/scripts/build/copyFiles.ts

@@ -13,3 +13,11 @@ export type ChatItemType =
     | 'answer-stream'
     | 'answer-part'
     | 'code-result'
+
+export interface IManifestFile {
+    pomArtifactId: string
+    pomFolderName: string
+    hilCapability: string
+    pomGroupId: string
+    sourcePomVersion: string
+}

packages/core/src/amazonqFeatureDev/models.ts

@@ -27,6 +27,10 @@ export function init(appContext: AmazonQAppInitContext) {
         transformationFinished: new vscode.EventEmitter<any>(),
         processHumanChatMessage: new vscode.EventEmitter<any>(),
         linkClicked: new vscode.EventEmitter<any>(),
+        humanInTheLoopStartIntervention: new vscode.EventEmitter<any>(),
+        humanInTheLoopPromptUserForDependency: new vscode.EventEmitter<any>(),
+        humanInTheLoopSelectionUploaded: new vscode.EventEmitter<any>(),
+        errorThrown: new vscode.EventEmitter<any>(),
     }
 
     const dispatcher = new AppToWebViewMessageDispatcher(appContext.getAppsToWebViewMessagePublisher())

packages/core/src/amazonqGumby/app.ts

@@ -17,22 +17,31 @@ import { featureName } from '../../models/constants'
 import { AuthUtil } from '../../../codewhisperer/util/authUtil'
 import {
     compileProject,
+    finishHumanInTheLoop,
     getValidCandidateProjects,
+    openHilPomFile,
     processTransformFormInput,
     startTransformByQ,
     stopTransformByQ,
     validateCanCompileProject,
 } from '../../../codewhisperer/commands/startTransformByQ'
 import { JDKVersion, TransformationCandidateProject, transformByQState } from '../../../codewhisperer/models/model'
+import {
+    AlternateDependencyVersionsNotFoundError,
+    JavaHomeNotSetError,
+    ModuleUploadError,
+    NoJavaProjectsFoundError,
+    NoMavenJavaProjectsFoundError,
+} from '../../errors'
 import * as CodeWhispererConstants from '../../../codewhisperer/models/constants'
-import { JavaHomeNotSetError, NoJavaProjectsFoundError, NoMavenJavaProjectsFoundError } from '../../errors'
 import MessengerUtils, { ButtonActions, GumbyCommands } from './messenger/messengerUtils'
 import { CancelActionPositions } from '../../telemetry/codeTransformTelemetry'
 import { openUrl } from '../../../shared/utilities/vsCodeUtils'
 import { telemetry } from '../../../shared/telemetry/telemetry'
 import { MetadataResult } from '../../../shared/telemetry/telemetryClient'
 import { CodeTransformTelemetryState } from '../../telemetry/codeTransformTelemetryState'
 import { getAuthType } from '../../../codewhisperer/service/transformByQ/transformApiHandler'
+import DependencyVersions from '../../models/dependencies'
 
 // These events can be interactions within the chat,
 // or elsewhere in the IDE
@@ -46,6 +55,10 @@ export interface ChatControllerEventEmitters {
     readonly transformationFinished: vscode.EventEmitter<any>
     readonly processHumanChatMessage: vscode.EventEmitter<any>
     readonly linkClicked: vscode.EventEmitter<any>
+    readonly humanInTheLoopStartIntervention: vscode.EventEmitter<any>
+    readonly humanInTheLoopPromptUserForDependency: vscode.EventEmitter<any>
+    readonly humanInTheLoopSelectionUploaded: vscode.EventEmitter<any>
+    readonly errorThrown: vscode.EventEmitter<any>
 }
 
 export class GumbyController {
@@ -97,6 +110,22 @@ export class GumbyController {
         this.chatControllerMessageListeners.linkClicked.event(data => {
             this.openLink(data)
         })
+
+        this.chatControllerMessageListeners.humanInTheLoopStartIntervention.event(data => {
+            return this.startHILIntervention(data)
+        })
+
+        this.chatControllerMessageListeners.humanInTheLoopPromptUserForDependency.event(data => {
+            return this.HILPromptForDependency(data)
+        })
+
+        this.chatControllerMessageListeners.humanInTheLoopSelectionUploaded.event(data => {
+            return this.HILDependencySelectionUploaded(data)
+        })
+
+        this.chatControllerMessageListeners.errorThrown.event(data => {
+            return this.handleError(data)
+        })
     }
 
     private async tabOpened(message: any) {
@@ -143,7 +172,7 @@ export class GumbyController {
         // check that a project is open
         const workspaceFolders = vscode.workspace.workspaceFolders
         if (workspaceFolders === undefined || workspaceFolders.length === 0) {
-            this.messenger.sendRetryableErrorResponse('no-project-found', message.tabID)
+            this.messenger.sendUnrecoverableErrorResponse('no-project-found', message.tabID)
             return
         }
 
@@ -197,11 +226,11 @@ export class GumbyController {
             return await getValidCandidateProjects()
         } catch (err: any) {
             if (err instanceof NoJavaProjectsFoundError) {
-                this.messenger.sendRetryableErrorResponse('no-java-project-found', message.tabID)
+                this.messenger.sendUnrecoverableErrorResponse('no-java-project-found', message.tabID)
             } else if (err instanceof NoMavenJavaProjectsFoundError) {
-                this.messenger.sendRetryableErrorResponse('no-maven-java-project-found', message.tabID)
+                this.messenger.sendUnrecoverableErrorResponse('no-maven-java-project-found', message.tabID)
             } else {
-                this.messenger.sendRetryableErrorResponse('no-project-found', message.tabID)
+                this.messenger.sendUnrecoverableErrorResponse('no-project-found', message.tabID)
             }
         }
         return []
@@ -227,6 +256,16 @@ export class GumbyController {
                 this.messenger.sendCommandMessage({ ...message, command: GumbyCommands.CLEAR_CHAT })
                 await this.transformInitiated(message)
                 break
+            case ButtonActions.CONFIRM_DEPENDENCY_FORM:
+                await this.continueJobWithSelectedDependency({ ...message, tabID: message.tabId })
+                break
+            case ButtonActions.CANCEL_DEPENDENCY_FORM:
+                this.messenger.sendUserPrompt('Cancel', message.tabId)
+                await this.continueTransformationWithoutHIL({ tabID: message.tabId })
+                break
+            case ButtonActions.OPEN_FILE:
+                await openHilPomFile()
+                break
         }
     }
 
@@ -246,7 +285,7 @@ export class GumbyController {
         this.messenger.sendProjectSelectionMessage(projectName, fromJDKVersion, toJDKVersion, message.tabID)
 
         if (fromJDKVersion === JDKVersion.UNSUPPORTED) {
-            this.messenger.sendRetryableErrorResponse('unsupported-source-jdk-version', message.tabID)
+            this.messenger.sendUnrecoverableErrorResponse('unsupported-source-jdk-version', message.tabID)
             return
         }
 
@@ -267,7 +306,7 @@ export class GumbyController {
             this.messenger.sendCompilationInProgress(message.tabID)
             await compileProject()
         } catch (err: any) {
-            this.messenger.sendRetryableErrorResponse('could-not-compile-project', message.tabID)
+            this.messenger.sendUnrecoverableErrorResponse('could-not-compile-project', message.tabID)
             // reset state to allow "Start a new transformation" button to work
             this.sessionStorage.getSession().conversationState = ConversationState.IDLE
             throw err
@@ -310,12 +349,26 @@ export class GumbyController {
         await this.prepareProjectForSubmission(message)
     }
 
-    private async transformationFinished(data: { message: string; tabID: string }) {
+    private async transformationFinished(data: { message?: string; tabID: string }) {
         this.sessionStorage.getSession().conversationState = ConversationState.IDLE
         // at this point job is either completed, partially_completed, cancelled, or failed
         this.messenger.sendJobFinishedMessage(data.tabID, data.message)
     }
 
+    private startHILIntervention(data: { tabID: string; codeSnippet: string }) {
+        this.sessionStorage.getSession().conversationState = ConversationState.WAITING_FOR_INPUT
+        this.messenger.sendHumanInTheLoopInitialMessage(data.tabID, data.codeSnippet)
+    }
+
+    private HILPromptForDependency(data: { tabID: string; dependencies: DependencyVersions }) {
+        this.messenger.sendDependencyVersionsFoundMessage(data.dependencies, data.tabID)
+    }
+
+    private HILDependencySelectionUploaded(data: { tabID: string }) {
+        this.sessionStorage.getSession().conversationState = ConversationState.JOB_SUBMITTED
+        this.messenger.sendHILResumeMessage(data.tabID)
+    }
+
     private async processHumanChatMessage(data: { message: string; tabID: string }) {
         this.messenger.sendUserPrompt(data.message, data.tabID)
         this.messenger.sendChatInputEnabled(data.tabID, false)
@@ -332,15 +385,47 @@ export class GumbyController {
                         tabID: data.tabID,
                     })
                 } else {
-                    this.messenger.sendRetryableErrorResponse('invalid-java-home', data.tabID)
+                    this.messenger.sendUnrecoverableErrorResponse('invalid-java-home', data.tabID)
                 }
             }
         }
     }
 
+    private async continueJobWithSelectedDependency(message: { tabID: string; formSelectedValues: any }) {
+        const selectedDependency = message.formSelectedValues['GumbyTransformDependencyForm']
+        this.messenger.sendHILContinueMessage(message.tabID, selectedDependency)
+        await finishHumanInTheLoop(selectedDependency)
+    }
+
     private openLink(message: { link: string }) {
         void openUrl(vscode.Uri.parse(message.link))
     }
+
+    private async handleError(message: { error: Error; tabID: string }) {
+        if (message.error instanceof AlternateDependencyVersionsNotFoundError) {
+            this.messenger.sendKnownErrorResponse('no-alternate-dependencies-found', message.tabID)
+            await this.continueTransformationWithoutHIL(message)
+        } else if (message.error instanceof ModuleUploadError) {
+            this.messenger.sendKnownErrorResponse('upload-to-s3-failed', message.tabID)
+            await this.transformationFinished(message)
+        } else {
+            this.messenger.sendErrorMessage(message.error.message, message.tabID)
+        }
+    }
+
+    private async continueTransformationWithoutHIL(message: { tabID: string }) {
+        this.sessionStorage.getSession().conversationState = ConversationState.JOB_SUBMITTED
+        CodeTransformTelemetryState.instance.setCodeTransformMetaDataField({
+            canceledFromChat: true,
+        })
+        try {
+            await finishHumanInTheLoop()
+        } catch (err: any) {
+            await this.transformationFinished({ tabID: message.tabID })
+        }
+
+        this.messenger.sendStaticTextResponse('end-HIL-early', message.tabID)
+    }
 }
 
 /**