refactor: do not export gitdiff

Author: Hweinstock

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

@@ -28,8 +28,9 @@ import { FeatureUseCase } from '../models/constants'
 import { ProjectZipError } from '../../amazonqTest/error'
 import { normalize } from '../../shared/utilities/pathUtils'
 import { ZipStream } from '../../shared/utilities/zipStream'
-import { getTextContent } from '../../shared/utilities/vsCodeUtils'
-import { getGitDiffContent } from '../../amazonq/util/gitDiffUtils'
+import { getTextContent } from '../../shared/utilities/textDocumentUtilities'
+import { ChildProcess, ChildProcessOptions } from '../../shared/utilities/processUtils'
+import { removeAnsi } from '../../shared/utilities/textUtilities'
 
 export interface ZipMetadata {
     rootDir: string
@@ -217,7 +218,7 @@ export class ZipUtil {
         filePath?: string,
         scope?: CodeWhispererConstants.CodeAnalysisScope
     ) {
-        const gitDiffContent = await getGitDiffContent(projectPaths, filePath)
+        const gitDiffContent = await getGitDiffContentForProjects(projectPaths, filePath)
         if (gitDiffContent) {
             zip.writeString(gitDiffContent, ZipConstants.codeDiffFilePath)
         }
@@ -451,3 +452,173 @@ export class ZipUtil {
         logger.verbose(`Complete cleaning up temporary files.`)
     }
 }
+
+// TODO: port this to its own utility with tests.
+interface GitDiffOptions {
+    projectPath: string
+    projectName: string
+    filepath?: string
+    scope?: CodeWhispererConstants.CodeAnalysisScope
+}
+
+async function getGitDiffContentForProjects(
+    projectPaths: string[],
+    filepath?: string,
+    scope?: CodeWhispererConstants.CodeAnalysisScope
+) {
+    let gitDiffContent = ''
+    for (const projectPath of projectPaths) {
+        const projectName = path.basename(projectPath)
+        gitDiffContent += await getGitDiffContent({
+            projectPath,
+            projectName,
+            filepath,
+            scope,
+        })
+    }
+    return gitDiffContent
+}
+
+async function getGitDiffContent(options: GitDiffOptions): Promise<string> {
+    const { projectPath, projectName, filepath: filePath, scope } = options
+    const isProjectScope = scope === CodeWhispererConstants.CodeAnalysisScope.PROJECT
+
+    const untrackedFilesString = await getGitUntrackedFiles(projectPath)
+    const untrackedFilesArray = untrackedFilesString?.trim()?.split('\n')?.filter(Boolean)
+
+    if (isProjectScope && untrackedFilesArray && !untrackedFilesArray.length) {
+        return await generateHeadDiff(projectPath, projectName)
+    }
+
+    let diffContent = ''
+
+    if (isProjectScope) {
+        diffContent = await generateHeadDiff(projectPath, projectName)
+
+        if (untrackedFilesArray) {
+            const untrackedDiffs = await Promise.all(
+                untrackedFilesArray.map((file) => generateNewFileDiff(projectPath, projectName, file))
+            )
+            diffContent += untrackedDiffs.join('')
+        }
+    } else if (!isProjectScope && filePath) {
+        const relativeFilePath = path.relative(projectPath, filePath)
+
+        const newFileDiff = await generateNewFileDiff(projectPath, projectName, relativeFilePath)
+        diffContent = rewriteDiff(newFileDiff)
+    }
+    return diffContent
+}
+
+async function getGitUntrackedFiles(projectPath: string): Promise<string | undefined> {
+    const checkNewFileArgs = ['ls-files', '--others', '--exclude-standard']
+    const checkProcess = new ChildProcess('git', checkNewFileArgs)
+
+    try {
+        let output = ''
+        await checkProcess.run({
+            rejectOnError: true,
+            rejectOnErrorCode: true,
+            onStdout: (text) => {
+                output += text
+            },
+            spawnOptions: {
+                cwd: projectPath,
+            },
+        })
+        return output
+    } catch (err) {
+        getLogger().warn(`Failed to check if file is new: ${err}`)
+        return undefined
+    }
+}
+
+async function generateHeadDiff(projectPath: string, projectName: string, relativePath?: string): Promise<string> {
+    let diffContent = ''
+
+    const gitArgs = [
+        'diff',
+        'HEAD',
+        `--src-prefix=a/${projectName}/`,
+        `--dst-prefix=b/${projectName}/`,
+        ...(relativePath ? [relativePath] : []),
+    ]
+
+    const childProcess = new ChildProcess('git', gitArgs)
+
+    const runOptions: ChildProcessOptions = {
+        rejectOnError: true,
+        rejectOnErrorCode: true,
+        onStdout: (text) => {
+            diffContent += text
+            getLogger().verbose(removeAnsi(text))
+        },
+        onStderr: (text) => {
+            getLogger().error(removeAnsi(text))
+        },
+        spawnOptions: {
+            cwd: projectPath,
+        },
+    }
+
+    try {
+        await childProcess.run(runOptions)
+        return diffContent
+    } catch (err) {
+        getLogger().warn(`Failed to run command \`${childProcess.toString()}\`: ${err}`)
+        return ''
+    }
+}
+
+async function generateNewFileDiff(projectPath: string, projectName: string, relativePath: string): Promise<string> {
+    let diffContent = ''
+
+    const gitArgs = [
+        'diff',
+        '--no-index',
+        `--src-prefix=a/${projectName}/`,
+        `--dst-prefix=b/${projectName}/`,
+        '/dev/null', // Use /dev/null as the old file
+        relativePath,
+    ]
+
+    const childProcess = new ChildProcess('git', gitArgs)
+    const runOptions: ChildProcessOptions = {
+        rejectOnError: false,
+        rejectOnErrorCode: false,
+        onStdout: (text) => {
+            diffContent += text
+            getLogger().verbose(removeAnsi(text))
+        },
+        onStderr: (text) => {
+            getLogger().error(removeAnsi(text))
+        },
+        spawnOptions: {
+            cwd: projectPath,
+        },
+    }
+
+    try {
+        await childProcess.run(runOptions)
+        return diffContent
+    } catch (err) {
+        getLogger().warn(`Failed to run diff command: ${err}`)
+        return ''
+    }
+}
+
+function rewriteDiff(inputStr: string): string {
+    const lines = inputStr.split('\n')
+    const rewrittenLines = lines.slice(0, 5).map((line) => {
+        line = line.replace(/\\\\/g, '/')
+        line = line.replace(/("a\/[^"]*)/g, (match, p1) => p1)
+        line = line.replace(/("b\/[^"]*)/g, (match, p1) => p1)
+        line = line.replace(/"/g, '')
+
+        return line
+    })
+    const outputLines = [...rewrittenLines, ...lines.slice(5)]
+    const outputStr = outputLines.join('\n')
+
+    return outputStr
+}

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

@@ -267,3 +267,9 @@ class ReadonlyDocument {
 }
 
 export const readonlyDocument = new ReadonlyDocument()
+
+export async function getTextContent(uri: vscode.Uri) {
+    const document = await vscode.workspace.openTextDocument(uri)
+    const content = document.getText()
+    return content
+}

packages/core/src/shared/utilities/textDocumentUtilities.ts

@@ -254,9 +254,3 @@ export function subscribeOnce<T>(event: vscode.Event<T>): vscode.Event<T> {
         return result
     }
 }
-
-export async function getTextContent(uri: vscode.Uri) {
-    const document = await vscode.workspace.openTextDocument(uri)
-    const content = document.getText()
-    return content
-}