fix(amazonq): always use projectName in zipEntryPath #6182

## Problem
Projects with a nested folder of the same name does not scan properly.

For example if the project name is `foo`, and there exists a folder
`foo/foo/` then the zip artifact only contains the inner `foo/` folder.

## Solution
Always include the project name in the zip artifact instead of
conditionally adding it.

Author: ctlai95

packages/amazonq/.changes/next-release/Bug Fix-d5c39800-ce37-4f6c-be23-9cc4035d0cef.json

@@ -0,0 +1,4 @@
+{
+	"type": "Bug Fix",
+	"description": "Code Review: Fixed a bug where projects with repeated path names did not scan properly."
+}

packages/amazonq/test/unit/codewhisperer/util/zipUtil.test.ts

@@ -14,11 +14,13 @@ import { ToolkitError } from 'aws-core-vscode/shared'
 import { LspClient } from 'aws-core-vscode/amazonq'
 import { fs } from 'aws-core-vscode/shared'
 import path from 'path'
+import JSZip from 'jszip'
 
 describe('zipUtil', function () {
     const workspaceFolder = getTestWorkspaceFolder()
     const appRoot = join(workspaceFolder, 'java11-plain-maven-sam-app')
     const appCodePath = join(appRoot, 'HelloWorldFunction', 'src', 'main', 'java', 'helloworld', 'App.java')
+    const appCodePathWithRepeatedProjectName = join(workspaceFolder, 'workspaceFolder', 'App.java')
 
     describe('getProjectPaths', function () {
         it('Should return the correct project paths', function () {
@@ -112,6 +114,30 @@ describe('zipUtil', function () {
             )
             assert.equal(zipMetadata2.lines, zipMetadata.lines + 1)
         })
+
+        it('should handle path with repeated project name for file scan', async function () {
+            const zipMetadata = await zipUtil.generateZip(
+                vscode.Uri.file(appCodePathWithRepeatedProjectName),
+                CodeAnalysisScope.FILE_ON_DEMAND
+            )
+
+            const zipFileData = await fs.readFileBytes(zipMetadata.zipFilePath)
+            const zip = await JSZip.loadAsync(zipFileData)
+            const files = Object.keys(zip.files)
+            assert.ok(files.includes(join('workspaceFolder', 'workspaceFolder', 'App.java')))
+        })
+
+        it('should handle path with repeated project name for project scan', async function () {
+            const zipMetadata = await zipUtil.generateZip(
+                vscode.Uri.file(appCodePathWithRepeatedProjectName),
+                CodeAnalysisScope.PROJECT
+            )
+
+            const zipFileData = await fs.readFileBytes(zipMetadata.zipFilePath)
+            const zip = await JSZip.loadAsync(zipFileData)
+            const files = Object.keys(zip.files)
+            assert.ok(files.includes(join('workspaceFolder', 'workspaceFolder', 'App.java')))
+        })
     })
 
     describe('generateZipTestGen', function () {

packages/core/src/codewhisperer/util/zipUtil.ts

@@ -140,14 +140,8 @@ export class ZipUtil {
         return zipFilePath
     }
 
-    protected getZipEntryPath(projectName: string, relativePath: string, useCase?: ZipUseCase) {
-        // Workspaces with multiple folders have the folder names as the root folder,
-        // but workspaces with only a single folder don't. So prepend the workspace folder name
-        // if it is not present.
-        if (useCase === ZipUseCase.TEST_GENERATION) {
-            return path.join(projectName, relativePath)
-        }
-        return relativePath.split('/').shift() === projectName ? relativePath : path.join(projectName, relativePath)
+    protected getZipEntryPath(projectName: string, relativePath: string) {
+        return path.join(projectName, relativePath)
     }
 
     /**
@@ -422,7 +416,8 @@ export class ZipUtil {
             this.getProjectScanPayloadSizeLimitInBytes()
         )
         for (const file of sourceFiles) {
-            const zipEntryPath = this.getZipEntryPath(file.workspaceFolder.name, file.relativeFilePath, useCase)
+            const projectName = path.basename(file.workspaceFolder.uri.fsPath)
+            const zipEntryPath = this.getZipEntryPath(projectName, file.relativeFilePath)
 
             if (ZipConstants.knownBinaryFileExts.includes(path.extname(file.fileUri.fsPath))) {
                 if (useCase === ZipUseCase.TEST_GENERATION) {

packages/core/src/testFixtures/workspaceFolder/workspaceFolder/App.java

@@ -0,0 +1,48 @@
+package helloworld;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import com.amazonaws.services.lambda.runtime.Context;
+import com.amazonaws.services.lambda.runtime.RequestHandler;
+import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
+import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
+
+/**
+ * Handler for requests to Lambda function.
+ */
+public class App implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
+
+    public APIGatewayProxyResponseEvent handleRequest(final APIGatewayProxyRequestEvent input, final Context context) {
+        Map<String, String> headers = new HashMap<>();
+        headers.put("Content-Type", "application/json");
+        headers.put("X-Custom-Header", "application/json");
+
+        APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent()
+                .withHeaders(headers);
+        try {
+            final String pageContents = this.getPageContents("https://checkip.amazonaws.com");
+            String output = String.format("{ \"message\": \"hello world\", \"location\": \"%s\" }", pageContents);
+
+            return response
+                    .withStatusCode(200)
+                    .withBody(output);
+        } catch (IOException e) {
+            return response
+                    .withBody("{}")
+                    .withStatusCode(500);
+        }
+    }
+
+    private String getPageContents(String address) throws IOException{
+        URL url = new URL(address);
+        try(BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()))) {
+            return br.lines().collect(Collectors.joining(System.lineSeparator()));
+        }
+    }
+}