fix(chat): Add more fsWrite validation and validate before diff view (aws#7054)

## Problem
- Sometimes the fsWrite input is invalid causing the diff view to show 0
changes

## Solution
- Add more fsWrite validation and validate before diff view


---

- Treat all work as PUBLIC. Private `feature/x` branches will not be
squash-merged at release time.
- Your code changes must meet the guidelines in
[CONTRIBUTING.md](https://github.com/aws/aws-toolkit-vscode/blob/master/CONTRIBUTING.md#guidelines).
- License: I confirm that my contribution is made under the terms of the
Apache 2.0 license.

Author: jguoamz

packages/core/src/codewhispererChat/controllers/chat/messenger/messenger.ts

@@ -330,6 +330,8 @@ export class Messenger {
                                         )
                                         explanation = input.explanation
                                     }
+                                    // validate the fsWrite tool input before showing the diff view
+                                    await tool.tool.validate()
                                     session.setShowDiffOnFileWrite(true)
                                     changeList = await tool.tool.getDiffChanges()
                                 }

packages/core/src/codewhispererChat/tools/fsWrite.ts

@@ -17,8 +17,7 @@ interface BaseParams {
 
 export interface CreateParams extends BaseParams {
     command: 'create'
-    fileText?: string
-    newStr?: string
+    fileText: string
 }
 
 export interface StrReplaceParams extends BaseParams {
@@ -111,31 +110,50 @@ export class FsWrite {
             oldContent = await fs.readFileText(sanitizedPath)
             isNew = false
         } catch (err) {
+            this.logger.warn('old content does not exist, set it to empty string')
             oldContent = ''
             isNew = true
         }
         return { filePath: sanitizedPath, content: oldContent, isNew }
     }
 
     public async validate(): Promise<void> {
+        if (!this.params.path) {
+            throw new Error('Path must not be empty')
+        }
+        const sanitizedPath = sanitizePath(this.params.path)
         switch (this.params.command) {
-            case 'create':
-                if (!this.params.path) {
-                    throw new Error('Path must not be empty')
+            case 'create': {
+                if (this.params.fileText === undefined) {
+                    throw new Error('fileText must be provided for create command')
+                }
+                const fileExists = await fs.existsFile(sanitizedPath)
+                if (fileExists) {
+                    const oldContent = await fs.readFileText(sanitizedPath)
+                    if (oldContent === this.params.fileText) {
+                        throw new Error('The file already exists with the same content')
+                    }
                 }
                 break
-            case 'strReplace':
+            }
+            case 'strReplace': {
+                if (this.params.oldStr === this.params.newStr) {
+                    throw new Error('The provided oldStr and newStr are the exact same, this is a no-op')
+                }
+                const fileExists = await fs.existsFile(sanitizedPath)
+                if (!fileExists) {
+                    throw new Error('The provided path must exist in order to replace contents into it')
+                }
+                break
+            }
             case 'insert': {
-                const fileExists = await fs.existsFile(this.params.path)
+                const fileExists = await fs.existsFile(sanitizedPath)
                 if (!fileExists) {
-                    throw new Error('The provided path must exist in order to replace or insert contents into it')
+                    throw new Error('The provided path must exist in order to insert contents into it')
                 }
                 break
             }
             case 'append':
-                if (!this.params.path) {
-                    throw new Error('Path must not be empty')
-                }
                 if (!this.params.newStr) {
                     throw new Error('Content to append must not be empty')
                 }
@@ -220,15 +238,7 @@ export class FsWrite {
     }
 
     private getCreateCommandText(params: CreateParams): string {
-        if (params.fileText) {
-            return params.fileText
-        }
-        if (params.newStr) {
-            this.logger.warn('Required field `fileText` is missing, use the provided `newStr` instead')
-            return params.newStr
-        }
-        this.logger.warn('No content provided for the create command')
-        return ''
+        return params.fileText
     }
 
     private escapeRegExp(string: string): string {

packages/core/src/test/codewhispererChat/tools/fsWrite.test.ts

@@ -66,39 +66,6 @@ describe('FsWrite Tool', function () {
 
             assert.deepStrictEqual(output, expectedOutput)
         })
-
-        it('uses newStr when fileText is not provided', async function () {
-            const filePath = path.join(testFolder.path, 'file2.txt')
-
-            const params: CreateParams = {
-                command: 'create',
-                newStr: 'Hello World',
-                path: filePath,
-            }
-            const fsWrite = new FsWrite(params)
-            const output = await fsWrite.invoke(process.stdout)
-
-            const content = await fs.readFileText(filePath)
-            assert.strictEqual(content, 'Hello World')
-
-            assert.deepStrictEqual(output, expectedOutput)
-        })
-
-        it('creates an empty file when no content is provided', async function () {
-            const filePath = path.join(testFolder.path, 'file3.txt')
-
-            const params: CreateParams = {
-                command: 'create',
-                path: filePath,
-            }
-            const fsWrite = new FsWrite(params)
-            const output = await fsWrite.invoke(process.stdout)
-
-            const content = await fs.readFileText(filePath)
-            assert.strictEqual(content, '')
-
-            assert.deepStrictEqual(output, expectedOutput)
-        })
     })
 
     describe('handleStrReplace', async function () {