fix(amazonq): add progressUpdates to TransformationHub (#4602

Problem
Needed to add progress updates to the Transformation Hub. Builds off of this old PR (#4575) which I closed because a lot of that work became unneeded & there were many merge conflicts; was easier to start over and add my desired changes on top of the latest work.

Author: dhasani23

.changes/next-release/Feature-c6272bd8-5538-4478-be87-490ada29be8e.json

@@ -0,0 +1,4 @@
+{
+	"type": "Feature",
+	"description": "Amazon Q Code Transformation: show detailed progress updates in Transformation Hub"
+}

packages/core/package.json

@@ -743,7 +743,7 @@
                     "type": "webview",
                     "id": "aws.amazonq.transformationHub",
                     "name": "Status",
-                    "when": "gumby.isTransformAvailable || gumby.isStopButtonAvailable"
+                    "when": "gumby.wasQCodeTransformationUsed"
                 },
                 {
                     "id": "aws.amazonq.transformationProposedChangesTree",
@@ -3753,12 +3753,6 @@
                     }
                 }
             },
-            {
-                "command": "aws.amazonq.startTransformationInHub",
-                "title": "Start Transformation",
-                "icon": "$(play)",
-                "enablement": "gumby.isTransformAvailable"
-            },
             {
                 "command": "aws.amazonq.stopTransformationInHub",
                 "title": "Stop Transformation",

packages/core/src/amazonq/explorer/amazonQChildrenNodes.ts

@@ -77,7 +77,6 @@ export const createTransformByQ = () => {
     const prefix = transformByQState.getPrefixTextForButton()
     let status = transformByQState.getPolledJobStatus().toLowerCase()
     if (transformByQState.isRunning()) {
-        void vscode.commands.executeCommand('setContext', 'gumby.isTransformAvailable', false)
         if (status === '') {
             // job is running but polling has not started yet, so display generic message
             status = CodeWhispererConstants.transformByQStateRunningMessage

packages/core/src/amazonq/explorer/amazonQTreeNode.ts

@@ -44,10 +44,8 @@ export class AmazonQNode implements TreeNode {
     }
 
     private getDescription(): string {
-        void vscode.commands.executeCommand('setContext', 'gumby.isTransformAvailable', false)
         if (AuthUtil.instance.isConnectionValid()) {
             if (AuthUtil.instance.isEnterpriseSsoInUse()) {
-                void vscode.commands.executeCommand('setContext', 'gumby.isTransformAvailable', true)
                 return 'IAM Identity Center Connected'
             } else if (AuthUtil.instance.isBuilderIdInUse()) {
                 return 'AWS Builder ID Connected'
@@ -61,7 +59,6 @@ export class AmazonQNode implements TreeNode {
     }
 
     public getChildren() {
-        void vscode.commands.executeCommand('setContext', 'gumby.isTransformAvailable', false)
         if (AuthUtil.instance.isConnectionExpired()) {
             return [createReconnect('tree'), createLearnMoreNode()]
         }
@@ -82,7 +79,6 @@ export class AmazonQNode implements TreeNode {
 
         const transformNode = []
         if (AuthUtil.instance.isValidCodeTransformationAuthUser()) {
-            void vscode.commands.executeCommand('setContext', 'gumby.isTransformAvailable', true)
             transformNode.push(createTransformByQ())
         }
 

packages/core/src/amazonqGumby/activation.ts

@@ -18,6 +18,7 @@ import { AuthUtil } from '../codewhisperer/util/authUtil'
 import { validateAndLogProjectDetails } from '../codewhisperer/service/transformByQHandler'
 
 export async function activate(context: ExtContext) {
+    void vscode.commands.executeCommand('setContext', 'gumby.wasQCodeTransformationUsed', false)
     // If the user is codewhisperer eligible, activate the plugin
     if (AuthUtil.instance.isValidCodeTransformationAuthUser()) {
         const transformationHubViewProvider = new TransformationHubViewProvider()

packages/core/src/codewhisperer/commands/startTransformByQ.ts

@@ -9,7 +9,13 @@ import * as fs from 'fs'
 import * as os from 'os'
 import { getLogger } from '../../shared/logger'
 import * as CodeWhispererConstants from '../models/constants'
-import { transformByQState, StepProgress, TransformByQReviewStatus, JDKVersion } from '../models/model'
+import {
+    transformByQState,
+    StepProgress,
+    TransformByQReviewStatus,
+    JDKVersion,
+    sessionPlanProgress,
+} from '../models/model'
 import { convertToTimeString, convertDateToTimestamp } from '../../shared/utilities/textUtilities'
 import {
     throwIfCancelled,
@@ -55,18 +61,6 @@ export const stopTransformByQButton = localize('aws.codewhisperer.stop.transform
 
 let sessionJobHistory: { timestamp: string; module: string; status: string; duration: string; id: string }[] = []
 
-const sessionPlanProgress: {
-    uploadCode: StepProgress
-    buildCode: StepProgress
-    transformCode: StepProgress
-    returnCode: StepProgress
-} = {
-    uploadCode: StepProgress.NotStarted,
-    buildCode: StepProgress.NotStarted,
-    transformCode: StepProgress.NotStarted,
-    returnCode: StepProgress.NotStarted,
-}
-
 export async function startTransformByQWithProgress() {
     await startTransformByQ()
 }
@@ -158,7 +152,7 @@ export async function startTransformByQ() {
                 'aws.amazonq.showPlanProgressInHub',
                 codeTransformTelemetryState.getStartTime()
             )
-        }, CodeWhispererConstants.progressIntervalMs)
+        }, CodeWhispererConstants.transformationJobPollingIntervalSeconds * 1000)
 
         // step 1: CreateCodeUploadUrl and upload code
         const uploadId = await preTransformationUploadCode()
@@ -173,6 +167,7 @@ export async function startTransformByQ() {
         const status = await pollTransformationStatusUntilComplete(jobId)
 
         // Set the result state variables for our store and the UI
+        // At this point job should be completed or partially completed
         await finalizeTransformationJob(status)
     } catch (error: any) {
         await transformationJobErrorHandler(error)
@@ -204,7 +199,6 @@ export async function preTransformationUploadCode() {
         })
         throw err
     }
-    sessionPlanProgress['uploadCode'] = StepProgress.Succeeded
 
     await sleep(2000) // sleep before starting job to prevent ThrottlingException
     throwIfCancelled()
@@ -238,7 +232,7 @@ export async function startTransformationJob(uploadId: string) {
 
 export async function pollTransformationStatusUntilPlanReady(jobId: string) {
     try {
-        await pollTransformationJob(jobId, CodeWhispererConstants.validStatesForGettingPlan)
+        await pollTransformationJob(jobId, CodeWhispererConstants.validStatesForPlanGenerated)
     } catch (error) {
         const errorMessage = CodeWhispererConstants.failedToCompleteJobMessage
         getLogger().error(`CodeTransformation: ${errorMessage}`, error)
@@ -254,7 +248,7 @@ export async function pollTransformationStatusUntilPlanReady(jobId: string) {
         transformByQState.setJobFailureErrorMessage(errorMessage)
         throw new Error('Get plan failed')
     }
-    sessionPlanProgress['buildCode'] = StepProgress.Succeeded
+
     const planFilePath = path.join(os.tmpdir(), 'transformation-plan.md')
     fs.writeFileSync(planFilePath, plan)
     await vscode.commands.executeCommand('markdown.showPreview', vscode.Uri.file(planFilePath))
@@ -286,7 +280,6 @@ export async function finalizeTransformationJob(status: string) {
         throw new Error('Job was not successful nor partially successful')
     }
 
-    sessionPlanProgress['transformCode'] = StepProgress.Succeeded
     transformByQState.setToSucceeded()
     if (status === 'PARTIALLY_COMPLETED') {
         transformByQState.setToPartiallySucceeded()
@@ -298,11 +291,7 @@ export async function finalizeTransformationJob(status: string) {
     await vscode.commands.executeCommand('aws.amazonq.transformationHub.reviewChanges.reveal')
     await vscode.commands.executeCommand('aws.amazonq.refresh')
 
-    transformByQState.getChatControllers()?.transformationFinished.fire({
-        jobStatus: status,
-        tabID: ChatSessionManager.Instance.getSession().tabID,
-    })
-    sessionPlanProgress['returnCode'] = StepProgress.Succeeded
+    sessionPlanProgress['transformCode'] = StepProgress.Succeeded
 }
 
 export async function getValidCandidateProjects(): Promise<TransformationCandidateProject[]> {
@@ -311,11 +300,13 @@ export async function getValidCandidateProjects(): Promise<TransformationCandida
 }
 
 export async function setTransformationToRunningState() {
+    await setContextVariables()
+
     transformByQState.setToRunning()
-    sessionPlanProgress['uploadCode'] = StepProgress.Pending
+    sessionPlanProgress['startJob'] = StepProgress.Pending
     sessionPlanProgress['buildCode'] = StepProgress.Pending
+    sessionPlanProgress['generatePlan'] = StepProgress.Pending
     sessionPlanProgress['transformCode'] = StepProgress.Pending
-    sessionPlanProgress['returnCode'] = StepProgress.Pending
 
     codeTransformTelemetryState.setStartTime()
 
@@ -343,13 +334,14 @@ export async function setTransformationToRunningState() {
         codeTransformTelemetryState.getStartTime()
     )
 
-    await setContextVariables()
-
     await vscode.commands.executeCommand('aws.amazonq.refresh')
 }
 
 export async function postTransformationJob() {
-    await vscode.commands.executeCommand('setContext', 'gumby.isTransformAvailable', true)
+    transformByQState.getChatControllers()?.transformationFinished.fire({
+        jobStatus: transformByQState.getPolledJobStatus(),
+        tabID: ChatSessionManager.Instance.getSession().tabID,
+    })
     const durationInMs = calculateTotalLatency(codeTransformTelemetryState.getStartTime())
     const resultStatusMessage = codeTransformTelemetryState.getResultStatus()
 
@@ -441,18 +433,18 @@ export async function transformationJobErrorHandler(error: any) {
                 }
             })
     }
-    if (sessionPlanProgress['uploadCode'] !== StepProgress.Succeeded) {
-        sessionPlanProgress['uploadCode'] = StepProgress.Failed
+    if (sessionPlanProgress['startJob'] !== StepProgress.Succeeded) {
+        sessionPlanProgress['startJob'] = StepProgress.Failed
     }
     if (sessionPlanProgress['buildCode'] !== StepProgress.Succeeded) {
         sessionPlanProgress['buildCode'] = StepProgress.Failed
     }
+    if (sessionPlanProgress['generatePlan'] !== StepProgress.Succeeded) {
+        sessionPlanProgress['generatePlan'] = StepProgress.Failed
+    }
     if (sessionPlanProgress['transformCode'] !== StepProgress.Succeeded) {
         sessionPlanProgress['transformCode'] = StepProgress.Failed
     }
-    if (sessionPlanProgress['returnCode'] !== StepProgress.Succeeded) {
-        sessionPlanProgress['returnCode'] = StepProgress.Failed
-    }
     getLogger().error(`CodeTransformation: ${error.message}`)
 }
 
@@ -509,8 +501,8 @@ export async function stopTransformByQ(
 }
 
 async function setContextVariables() {
+    await vscode.commands.executeCommand('setContext', 'gumby.wasQCodeTransformationUsed', true)
     await vscode.commands.executeCommand('setContext', 'gumby.isStopButtonAvailable', true)
-    await vscode.commands.executeCommand('setContext', 'gumby.isTransformAvailable', false)
     await vscode.commands.executeCommand('setContext', 'gumby.isPlanAvailable', false)
     await vscode.commands.executeCommand('setContext', 'gumby.isSummaryAvailable', false)
     await vscode.commands.executeCommand('setContext', 'gumby.reviewState', TransformByQReviewStatus.NotStarted)

packages/core/src/codewhisperer/models/constants.ts

@@ -401,12 +401,10 @@ export const transformByQStatePartialSuccessMessage = 'partially succeeded'
 
 export const transformByQStoppedState = 'STOPPED'
 
-export const transformationJobPollingIntervalSeconds = 10
+export const transformationJobPollingIntervalSeconds = 5
 
 export const transformationJobTimeoutSeconds = 60 * 60 // 1 hour, to match backend
 
-export const progressIntervalMs = 1000
-
 export const defaultLanguage = 'Java'
 
 export const contentChecksumType = 'SHA_256'
@@ -415,13 +413,26 @@ export const uploadIntent = 'TRANSFORMATION'
 
 export const transformationType = 'LANGUAGE_UPGRADE'
 
-// when in one of these states, we can definitely say the plan is available
-// in other states, we keep polling/waiting
-export const validStatesForGettingPlan = ['COMPLETED', 'PARTIALLY_COMPLETED', 'PLANNED', 'TRANSFORMING', 'TRANSFORMED']
+// job successfully started
+export const validStatesForJobStarted = [
+    'STARTED',
+    'PREPARING',
+    'PREPARED',
+    'PLANNING',
+    'PLANNED',
+    'TRANSFORMING',
+    'TRANSFORMED',
+]
+
+// initial build succeeded
+export const validStatesForBuildSucceeded = ['PREPARED', 'PLANNING', 'PLANNED', 'TRANSFORMING', 'TRANSFORMED']
+
+// plan must be available
+export const validStatesForPlanGenerated = ['PLANNED', 'TRANSFORMING', 'TRANSFORMED']
 
 export const failureStates = ['FAILED', 'STOPPING', 'STOPPED', 'REJECTED']
 
-// similarly, when in one of these states, we can stop polling, and if status is COMPLETED or PARTIALLY_COMPLETED we can download artifacts
+// if status is COMPLETED or PARTIALLY_COMPLETED we can download artifacts
 export const validStatesForCheckingDownloadUrl = [
     'COMPLETED',
     'PARTIALLY_COMPLETED',

packages/core/src/codewhisperer/models/model.ts

@@ -267,6 +267,18 @@ export enum DropdownStep {
     STEP_2 = 2,
 }
 
+export const sessionPlanProgress: {
+    startJob: StepProgress
+    buildCode: StepProgress
+    generatePlan: StepProgress
+    transformCode: StepProgress
+} = {
+    startJob: StepProgress.NotStarted,
+    buildCode: StepProgress.NotStarted,
+    generatePlan: StepProgress.NotStarted,
+    transformCode: StepProgress.NotStarted,
+}
+
 export class TransformByQState {
     private transformByQState: TransformByQStatus = TransformByQStatus.NotStarted
 

packages/core/src/codewhisperer/service/transformByQHandler.ts

@@ -3,7 +3,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { BuildSystem, JDKVersion, transformByQState, TransformByQStoppedError, ZipManifest } from '../models/model'
+import {
+    BuildSystem,
+    JDKVersion,
+    sessionPlanProgress,
+    StepProgress,
+    transformByQState,
+    TransformByQStoppedError,
+    ZipManifest,
+} from '../models/model'
 import * as codeWhisperer from '../client/codewhisperer'
 import * as crypto from 'crypto'
 import { getLogger } from '../../shared/logger'
@@ -846,6 +854,16 @@ export async function pollTransformationJob(jobId: string, validStates: string[]
                 result: MetadataResult.Pass,
             })
             status = response.transformationJob.status!
+            // must be series of ifs, not else ifs
+            if (CodeWhispererConstants.validStatesForJobStarted.includes(status)) {
+                sessionPlanProgress['startJob'] = StepProgress.Succeeded
+            }
+            if (CodeWhispererConstants.validStatesForBuildSucceeded.includes(status)) {
+                sessionPlanProgress['buildCode'] = StepProgress.Succeeded
+            }
+            if (CodeWhispererConstants.validStatesForPlanGenerated.includes(status)) {
+                sessionPlanProgress['generatePlan'] = StepProgress.Succeeded
+            }
             // emit metric when job status changes
             if (status !== transformByQState.getPolledJobStatus()) {
                 telemetry.codeTransform_jobStatusChanged.emit({

packages/core/src/codewhisperer/service/transformationHubViewProvider.ts

@@ -116,19 +116,24 @@ export class TransformationHubViewProvider implements vscode.WebviewViewProvider
     private async showPlanProgress(startTime: number): Promise<string> {
         const planProgress = getPlanProgress()
         let planSteps = undefined
-        if (planProgress['buildCode'] === StepProgress.Succeeded) {
+        if (planProgress['generatePlan'] === StepProgress.Succeeded) {
             planSteps = await getTransformationSteps(transformByQState.getJobId())
         }
         let progressHtml = `<p><b>Transformation Status</b></p><p>No job ongoing</p>`
-        if (planProgress['returnCode'] !== StepProgress.NotStarted) {
+        if (planProgress['transformCode'] !== StepProgress.NotStarted) {
             progressHtml = `<p><b>Transformation Status</b></p>`
-            progressHtml += `<p> ${this.getProgressIconMarkup(planProgress['uploadCode'])} Waiting for job to start</p>`
-            if (planProgress['uploadCode'] === StepProgress.Succeeded) {
+            progressHtml += `<p> ${this.getProgressIconMarkup(planProgress['startJob'])} Waiting for job to start</p>`
+            if (planProgress['startJob'] === StepProgress.Succeeded) {
                 progressHtml += `<p> ${this.getProgressIconMarkup(
                     planProgress['buildCode']
-                )} Build uploaded code in secure build environment and generate transformation plan</p>`
+                )} Build uploaded code in secure build environment</p>`
             }
             if (planProgress['buildCode'] === StepProgress.Succeeded) {
+                progressHtml += `<p> ${this.getProgressIconMarkup(
+                    planProgress['generatePlan']
+                )} Generate transformation plan</p>`
+            }
+            if (planProgress['generatePlan'] === StepProgress.Succeeded) {
                 progressHtml += `<p> ${this.getProgressIconMarkup(
                     planProgress['transformCode']
                 )} Transform your code to Java 17 using transformation plan</p>`
@@ -172,6 +177,11 @@ export class TransformationHubViewProvider implements vscode.WebviewViewProvider
                         if (step.progressUpdates) {
                             for (const subStep of step.progressUpdates) {
                                 progressHtml += `<p style="margin-left: 40px">- ${subStep.name}</p>`
+                                if (subStep.description) {
+                                    progressHtml += `<p style="margin-left: 60px; color:${this.getFontColorForSubStep(
+                                        subStep.status
+                                    )}">- ${subStep.description}</p>`
+                                }
                             }
                         }
                     }
@@ -248,4 +258,14 @@ export class TransformationHubViewProvider implements vscode.WebviewViewProvider
             return `<span style="color: grey"> ✓ </span>`
         }
     }
+
+    private getFontColorForSubStep(status: string) {
+        if (status === 'COMPLETED') {
+            return 'green'
+        } else if (status === 'FAILED') {
+            return 'red'
+        } else {
+            return '' // uses VS Code's default color
+        }
+    }
 }