temp

Author: Hweinstock

packages/core/src/amazonq/util/files.ts

@@ -144,7 +144,7 @@ export async function prepareRepoData(
                 excludePatterns: excludePatterns,
                 filterFn: filterFn,
             },
-            isExcluded,
+            { isExcluded },
             { zip: options?.zip ?? new ZipStream() }
         )
 

packages/core/src/amazonq/util/zipProjectUtil.ts

@@ -4,13 +4,11 @@
  */
 
 import path from 'path'
-import { fs } from '../../shared/fs/fs'
 import { collectFiles, CollectFilesOptions } from '../../shared/utilities/workspaceUtils'
 import { CurrentWsFolders } from '../commons/types'
 import { ZipStream } from '../../shared/utilities/zipStream'
-import { hasCode } from '../../shared/errors'
 
-export interface ZippedResult {
+export interface ZippedWorkspaceResult {
     zipFileBuffer: Buffer
     zipFileChecksum: string
     totalFileBytes: number
@@ -20,13 +18,19 @@ interface ZipProjectOptions {
     zip?: ZipStream
 }
 
+interface ZipProjectCustomizations {
+    isExcluded?: (relativePath: string, fileSize: number) => boolean
+    checkForError?: (relativePath: string, fileSize: number) => void | never
+    computeSideEffects?: (filePath: string) => Promise<void> | void
+}
+
 export async function zipProject(
     repoRootPaths: string[],
     workspaceFolders: CurrentWsFolders,
     collectFilesOptions: CollectFilesOptions,
-    isExcluded: (relativePath: string, fileSize: number) => boolean,
+    customizations?: ZipProjectCustomizations,
     options?: ZipProjectOptions
-): Promise<ZippedResult> {
+): Promise<ZippedWorkspaceResult> {
     const zip = options?.zip ?? new ZipStream()
     const files = await collectFiles(repoRootPaths, workspaceFolders, collectFilesOptions)
     const zippedFiles = new Set()
@@ -37,25 +41,18 @@ export async function zipProject(
         }
         zippedFiles.add(file.zipFilePath)
 
-        const fileSize = await fs
-            .stat(file.fileUri.fsPath)
-            .then((r) => r.size)
-            .catch((e) => {
-                if (hasCode(e) && e.code === 'ENOENT') {
-                    // No-op: Skip if file does not exist
-                    return
-                }
-                throw e
-            })
-        if (!fileSize) {
+        if (customizations?.isExcluded && customizations.isExcluded(file.relativeFilePath, file.fileSizeBytes)) {
             continue
         }
+        if (customizations?.checkForError) {
+            customizations.checkForError(file.relativeFilePath, file.fileSizeBytes)
+        }
 
-        if (isExcluded(file.relativeFilePath, fileSize)) {
-            continue
+        if (customizations?.computeSideEffects) {
+            await customizations.computeSideEffects(file.fileUri.fsPath)
         }
 
-        totalBytes += fileSize
+        totalBytes += file.fileSizeBytes
         // Paths in zip should be POSIX compliant regardless of OS
         // Reference: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
         const posixPath = file.zipFilePath.split(path.sep).join(path.posix.sep)

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

@@ -208,12 +208,8 @@ export class ZipUtil {
 
     protected async zipProject(useCase: FeatureUseCase, projectPath?: string, metadataDir?: string) {
         const zip = new admZip()
-        let projectPaths = []
-        if (useCase === FeatureUseCase.TEST_GENERATION && projectPath) {
-            projectPaths.push(projectPath)
-        } else {
-            projectPaths = this.getProjectPaths()
-        }
+        const projectPaths =
+            useCase === FeatureUseCase.TEST_GENERATION && projectPath ? [projectPath] : this.getProjectPaths()
         if (useCase === FeatureUseCase.CODE_SCAN) {
             await this.processCombinedGitDiff(zip, projectPaths, '', CodeWhispererConstants.CodeAnalysisScope.PROJECT)
         }
@@ -412,26 +408,30 @@ export class ZipUtil {
             return
         }
 
-        const sourceFiles = await collectFiles(
-            projectPaths,
-            (useCase === FeatureUseCase.TEST_GENERATION
+        const workspaceFolders = (
+            useCase === FeatureUseCase.TEST_GENERATION
                 ? [...(vscode.workspace.workspaceFolders ?? [])].sort(
                       (a, b) => b.uri.fsPath.length - a.uri.fsPath.length
                   )
-                : vscode.workspace.workspaceFolders) as CurrentWsFolders,
-            {
-                maxTotalSizeBytes: this.getProjectScanPayloadSizeLimitInBytes(),
-                excludePatterns:
-                    useCase === FeatureUseCase.TEST_GENERATION
-                        ? [...CodeWhispererConstants.testGenExcludePatterns, ...defaultExcludePatterns]
-                        : defaultExcludePatterns,
-            }
-        )
+                : vscode.workspace.workspaceFolders
+        ) as CurrentWsFolders
+
+        const collectFilesOptions = {
+            maxTotalSizeBytes: this.getProjectScanPayloadSizeLimitInBytes(),
+            excludePatterns:
+                useCase === FeatureUseCase.TEST_GENERATION
+                    ? [...CodeWhispererConstants.testGenExcludePatterns, ...defaultExcludePatterns]
+                    : defaultExcludePatterns,
+        }
+
+        const sourceFiles = await collectFiles(projectPaths, workspaceFolders, collectFilesOptions)
+
         for (const file of sourceFiles) {
             const projectName = path.basename(file.workspaceFolder.uri.fsPath)
             const zipEntryPath = this.getZipEntryPath(projectName, file.relativeFilePath)
+            const fileExtension = path.extname(file.fileUri.fsPath)
 
-            if (ZipConstants.knownBinaryFileExts.includes(path.extname(file.fileUri.fsPath))) {
+            if (ZipConstants.knownBinaryFileExts.includes(fileExtension)) {
                 if (useCase === FeatureUseCase.TEST_GENERATION) {
                     continue
                 }