feat(gumby): run mvnw if mvn fails #4290

Problem:
When `mvn` fails, we want to run `mvnw` because that may succeed, since the user
could have the Maven wrapper in their workspace despite not having Maven
installed.

Solution:
Run `mvnw` when `mvn` fails.
Also:
1. slight renaming
2. collect input in a simpler way (no need to use `MultiStepInputFlowController`
   since we only collect 1 piece of input).

Author: dhasani23

.changes/next-release/Feature-46a5faf6-6909-48b4-bce3-d74e390b5519.json

@@ -0,0 +1,4 @@
+{
+	"type": "Feature",
+	"description": "Amazon Q CodeTransform: use Maven wrapper (if present) to copy dependencies if Maven not installed"
+}

src/codewhisperer/commands/startTransformByQ.ts

@@ -9,7 +9,7 @@ import * as fs from 'fs'
 import * as os from 'os'
 import { getLogger } from '../../shared/logger'
 import * as CodeWhispererConstants from '../models/constants'
-import { transformByQState, StepProgress, DropdownStep, TransformByQReviewStatus } from '../models/model'
+import { transformByQState, StepProgress, TransformByQReviewStatus } from '../models/model'
 import {
     throwIfCancelled,
     startJob,
@@ -24,7 +24,6 @@ import {
     validateProjectSelection,
 } from '../service/transformByQHandler'
 import { QuickPickItem } from 'vscode'
-import { MultiStepInputFlowController } from '../../shared//multiStepInputFlowController'
 import path from 'path'
 import { sleep } from '../../shared/utilities/timeoutUtils'
 import { encodeHTML } from '../../shared/utilities/textUtilities'
@@ -73,38 +72,25 @@ interface UserInputState {
     project: QuickPickItem
 }
 
-async function collectInputs(validProjects: vscode.QuickPickItem[] | undefined) {
-    // const targetLanguages: QuickPickItem[] = CodeWhispererConstants.targetLanguages.map(label => ({ label }))
+async function collectInput(validProjects: vscode.QuickPickItem[]) {
     const state = {} as Partial<UserInputState>
-    // only supporting target language of Java and target version of JDK17 for now, so skip to pickModule prompt
     transformByQState.setTargetJDKVersionToJDK17()
-    await MultiStepInputFlowController.run(input => pickProject(input, state, validProjects))
-    // await MultiStepInputFlowController.run(input => pickTargetLanguage(input, state, targetLanguages, validModules))
-    return state as UserInputState
-}
-
-async function pickProject(
-    input: MultiStepInputFlowController,
-    state: Partial<UserInputState>,
-    validProjects: vscode.QuickPickItem[] | undefined
-) {
-    const pick = await input.showQuickPick({
+    const pick = await vscode.window.showQuickPick(validProjects, {
         title: CodeWhispererConstants.transformByQWindowTitle,
-        step: DropdownStep.STEP_1,
-        totalSteps: DropdownStep.STEP_1,
-        placeholder: CodeWhispererConstants.selectModulePrompt,
-        items: validProjects!,
-        shouldResume: () => Promise.resolve(false),
+        placeHolder: CodeWhispererConstants.selectModulePrompt,
     })
-    state.project = pick
-    transformByQState.setProjectName(encodeHTML(state.project.label)) // encode to avoid HTML injection risk
+    if (pick) {
+        state.project = pick
+        transformByQState.setProjectName(encodeHTML(state.project.label)) // encode to avoid HTML injection risk
+    }
+    return state as UserInputState
 }
 
 export async function startTransformByQ() {
     let intervalId = undefined
 
-    // 1: Validate inputs. If failed, Error will be thrown and execution stops
-    const userInputState = await validateTransformJob()
+    // Validate inputs. If failed, Error will be thrown and execution stops
+    const userInputState = await validateTransformationJob()
 
     // Set the default state variables for our store and the UI
     await setTransformationToRunningState(userInputState)
@@ -119,29 +105,28 @@ export async function startTransformByQ() {
         }, CodeWhispererConstants.progressIntervalMs)
 
         // step 1: CreateCodeUploadUrl and upload code
-        const uploadId = await preTransformUploadCode(userInputState)
+        const uploadId = await preTransformationUploadCode(userInputState)
 
         // step 2: StartJob and store the returned jobId in TransformByQState
-        const jobId = await transformStartJob(uploadId)
+        const jobId = await startTransformationJob(uploadId)
 
         // step 3 (intermediate step): show transformation-plan.md file
-        // TO-DO: on IDE restart, resume here if a job was ongoing
-        await pollTransformationStatusTillPlanReady(jobId)
+        await pollTransformationStatusUntilPlanReady(jobId)
 
         // step 4: poll until artifacts are ready to download
-        const status = await pollTransformationTillComplete(jobId)
+        const status = await pollTransformationStatusUntilComplete(jobId)
 
         // Set the result state variables for our store and the UI
         await finalizeTransformationJob(status)
     } catch (error: any) {
-        await modernizationJobErrorHandler(error)
+        await transformationJobErrorHandler(error)
     } finally {
-        await postTransformJob(userInputState)
-        await cleanupTransformJob(intervalId)
+        await postTransformationJob(userInputState)
+        await cleanupTransformationJob(intervalId)
     }
 }
 
-export async function preTransformUploadCode(userInputState: UserInputState) {
+export async function preTransformationUploadCode(userInputState: UserInputState) {
     await vscode.commands.executeCommand('aws.amazonq.refresh')
     await vscode.commands.executeCommand('aws.amazonq.transformationHub.focus')
 
@@ -173,7 +158,7 @@ export async function preTransformUploadCode(userInputState: UserInputState) {
     return uploadId
 }
 
-export async function transformStartJob(uploadId: string) {
+export async function startTransformationJob(uploadId: string) {
     let jobId = ''
     try {
         jobId = await startJob(uploadId)
@@ -197,7 +182,7 @@ export async function transformStartJob(uploadId: string) {
     return jobId
 }
 
-export async function pollTransformationStatusTillPlanReady(jobId: string) {
+export async function pollTransformationStatusUntilPlanReady(jobId: string) {
     try {
         await pollTransformationJob(jobId, CodeWhispererConstants.validStatesForGettingPlan)
     } catch (error) {
@@ -223,7 +208,7 @@ export async function pollTransformationStatusTillPlanReady(jobId: string) {
     throwIfCancelled()
 }
 
-export async function pollTransformationTillComplete(jobId: string) {
+export async function pollTransformationStatusUntilComplete(jobId: string) {
     let status = ''
     try {
         status = await pollTransformationJob(jobId, CodeWhispererConstants.validStatesForCheckingDownloadUrl)
@@ -260,15 +245,19 @@ export async function finalizeTransformationJob(status: string) {
     sessionPlanProgress['returnCode'] = StepProgress.Succeeded
 }
 
-export async function validateTransformJob() {
+export async function validateTransformationJob() {
     let openProjects: vscode.QuickPickItem[] = []
     try {
         openProjects = await getOpenProjects()
     } catch (err) {
         getLogger().error('Failed to get open projects: ', err)
         throw err
     }
-    const userInputState = await collectInputs(openProjects)
+    const userInputState = await collectInput(openProjects)
+
+    if (!userInputState.project) {
+        throw new ToolkitError('No project selected', { code: 'NoProjectSelected' })
+    }
 
     try {
         await validateProjectSelection(userInputState.project)
@@ -333,7 +322,7 @@ export async function setTransformationToRunningState(userInputState: UserInputS
     await vscode.commands.executeCommand('aws.amazonq.refresh')
 }
 
-export async function postTransformJob(userInputState: UserInputState) {
+export async function postTransformationJob(userInputState: UserInputState) {
     await vscode.commands.executeCommand('setContext', 'gumby.isTransformAvailable', true)
     const durationInMs = calculateTotalLatency(codeTransformTelemetryState.getStartTime())
     const resultStatusMessage = codeTransformTelemetryState.getResultStatus()
@@ -368,7 +357,7 @@ export async function postTransformJob(userInputState: UserInputState) {
     }
 }
 
-export async function modernizationJobErrorHandler(error: any) {
+export async function transformationJobErrorHandler(error: any) {
     if (transformByQState.isCancelled()) {
         codeTransformTelemetryState.setResultStatus('JobCancelled')
         try {
@@ -403,7 +392,7 @@ export async function modernizationJobErrorHandler(error: any) {
     getLogger().error('Amazon Q Code Transform', error)
 }
 
-export async function cleanupTransformJob(intervalId: NodeJS.Timeout | undefined) {
+export async function cleanupTransformationJob(intervalId: NodeJS.Timeout | undefined) {
     clearInterval(intervalId)
     transformByQState.setJobDefaults()
     await vscode.commands.executeCommand('setContext', 'gumby.isStopButtonAvailable', false)

src/codewhisperer/models/constants.ts

@@ -289,7 +289,7 @@ export const selectTargetVersionPrompt = 'Select the target version'
 
 export const selectModulePrompt = 'Select the module you want to transform'
 
-export const transformByQWindowTitle = 'Transform'
+export const transformByQWindowTitle = 'Amazon Q CodeTransformation'
 
 export const stopTransformByQMessage = 'Stop Transformation?'
 

src/codewhisperer/service/transformByQHandler.ts

@@ -18,7 +18,7 @@ import { spawnSync } from 'child_process'
 import AdmZip from 'adm-zip'
 import fetch from '../../common/request'
 import globals from '../../shared/extensionGlobals'
-import { telemetry } from '../../shared/telemetry/telemetry'
+import { CodeTransformMavenBuildCommand, telemetry } from '../../shared/telemetry/telemetry'
 import { ToolkitError } from '../../shared/errors'
 import { codeTransformTelemetryState } from '../../amazonqGumby/telemetry/codeTransformTelemetryState'
 import { calculateTotalLatency, javapOutputToTelemetryValue } from '../../amazonqGumby/telemetry/codeTransformTelemetry'
@@ -310,12 +310,24 @@ function getFilesRecursively(dir: string, isDependenciesFolder: boolean): string
     return files
 }
 
-function getProjectDependencies(modulePath: string): string[] {
+function getProjectDependencies(buildCommand: CodeTransformMavenBuildCommand, modulePath: string): string[] {
     // Make temp directory
     const folderName = `${CodeWhispererConstants.dependencyFolderName}${Date.now()}`
     const folderPath = path.join(os.tmpdir(), folderName)
 
-    const baseCommand = 'mvn'
+    let baseCommand = buildCommand as string
+    if (baseCommand === 'mvnw') {
+        baseCommand = './mvnw'
+        if (os.platform() === 'win32') {
+            baseCommand = './mvnw.cmd'
+        }
+        const executableName = baseCommand.substring(2) // remove the './' part
+        const executablePath = path.join(modulePath, executableName)
+        if (!fs.existsSync(executablePath)) {
+            throw new ToolkitError('Maven Wrapper not found', { code: 'MavenWrapperNotFound' })
+        }
+    }
+
     const args = [
         'dependency:copy-dependencies',
         '-DoutputDirectory=' + folderPath,
@@ -326,8 +338,7 @@ function getProjectDependencies(modulePath: string): string[] {
     const spawnResult = spawnSync(baseCommand, args, { cwd: modulePath, shell: true, encoding: 'utf-8' })
 
     if (spawnResult.error || spawnResult.status !== 0) {
-        void vscode.window.showErrorMessage(CodeWhispererConstants.dependencyErrorMessage)
-        getLogger().error('CodeTransform: Error in running Maven command = ')
+        getLogger().error(`CodeTransform: Error in running Maven command ${baseCommand} = `)
         // Maven command can still go through and still return an error. Won't be caught in spawnResult.error in this case
         if (spawnResult.error) {
             getLogger().error(spawnResult.error)
@@ -336,7 +347,7 @@ function getProjectDependencies(modulePath: string): string[] {
         }
         telemetry.codeTransform_mvnBuildFailed.emit({
             codeTransformSessionId: codeTransformTelemetryState.getSessionId(),
-            codeTransformMavenBuildCommand: baseCommand,
+            codeTransformMavenBuildCommand: buildCommand,
             result: MetadataResult.Fail,
             reason: spawnResult.error ? spawnResult.error.message : spawnResult.stdout,
         })
@@ -355,15 +366,30 @@ export async function zipCode(modulePath: string) {
     throwIfCancelled()
 
     let dependencyFolderInfo: string[] = []
-    let mavenFailed = false
+    let mavenWrapperFailed = false
     try {
-        dependencyFolderInfo = getProjectDependencies(modulePath)
+        dependencyFolderInfo = getProjectDependencies('mvnw', modulePath)
     } catch (err) {
-        mavenFailed = true
+        mavenWrapperFailed = true
+    }
+
+    let mavenFailed = false
+    if (mavenWrapperFailed) {
+        try {
+            dependencyFolderInfo = getProjectDependencies('mvn', modulePath)
+        } catch (err) {
+            mavenFailed = true
+        }
+    }
+
+    const copyDependenciesFailed = mavenFailed && mavenWrapperFailed
+
+    if (copyDependenciesFailed) {
+        void vscode.window.showErrorMessage(CodeWhispererConstants.dependencyErrorMessage)
     }
 
-    const dependencyFolderPath = !mavenFailed ? dependencyFolderInfo[0] : ''
-    const dependencyFolderName = !mavenFailed ? dependencyFolderInfo[1] : ''
+    const dependencyFolderPath = !copyDependenciesFailed ? dependencyFolderInfo[0] : ''
+    const dependencyFolderName = !copyDependenciesFailed ? dependencyFolderInfo[1] : ''
 
     throwIfCancelled()
 
@@ -379,11 +405,11 @@ export async function zipCode(modulePath: string) {
     throwIfCancelled()
 
     let dependencyFiles: string[] = []
-    if (!mavenFailed && fs.existsSync(dependencyFolderPath)) {
+    if (!copyDependenciesFailed && fs.existsSync(dependencyFolderPath)) {
         dependencyFiles = getFilesRecursively(dependencyFolderPath, true)
     }
 
-    if (!mavenFailed && dependencyFiles.length > 0) {
+    if (!copyDependenciesFailed && dependencyFiles.length > 0) {
         for (const file of dependencyFiles) {
             const relativePath = path.relative(dependencyFolderPath, file)
             const paddedPath = path.join(`dependencies/${dependencyFolderName}`, relativePath)
@@ -403,18 +429,18 @@ export async function zipCode(modulePath: string) {
 
     const tempFilePath = path.join(os.tmpdir(), 'zipped-code.zip')
     fs.writeFileSync(tempFilePath, zip.toBuffer())
-    if (!mavenFailed) {
+    if (!copyDependenciesFailed) {
         fs.rmSync(dependencyFolderPath, { recursive: true, force: true })
     }
 
     // for now, use the pass/fail status of the maven command to determine this metric status
-    const mavenStatus = mavenFailed ? MetadataResult.Fail : MetadataResult.Pass
+    const mavenStatus = copyDependenciesFailed ? MetadataResult.Fail : MetadataResult.Pass
     telemetry.codeTransform_jobCreateZipEndTime.emit({
         codeTransformSessionId: codeTransformTelemetryState.getSessionId(),
         codeTransformTotalByteSize: (await fs.promises.stat(tempFilePath)).size,
         codeTransformRunTimeLatency: calculateTotalLatency(zipStartTime),
         result: mavenStatus,
-        reason: mavenFailed ? 'MavenCommandFailed' : undefined,
+        reason: copyDependenciesFailed ? 'MavenCommandsFailed' : undefined,
     })
     return tempFilePath
 }