feat(amazonq): skip registering run command log file

Author: karanA-aws

packages/amazonq/.changes/next-release/Feature-86f056f5-4ac4-47be-8167-09c19a529a1e.json

@@ -0,0 +1,4 @@
+{
+	"type": "Feature",
+	"description": "The logs emitted by the Agent during user command execution will be accepted and written to .amazonq/dev/run_command.log file in the user's local repository."
+}

packages/core/src/amazonq/session/sessionState.ts

@@ -29,6 +29,7 @@ import { prepareRepoData, getDeletedFileInfos, registerNewFiles, PrepareRepoData
 import { uploadCode } from '../util/upload'
 
 export const EmptyCodeGenID = 'EMPTY_CURRENT_CODE_GENERATION_ID'
+const RunCommandLogFileName = '.amazonq/dev/run_command.log'
 
 export interface BaseMessenger {
     sendAnswer(params: any): void
@@ -103,6 +104,30 @@ export abstract class CodeGenBase {
                 case CodeGenerationStatus.COMPLETE: {
                     const { newFileContents, deletedFiles, references } =
                         await this.config.proxyClient.exportResultArchive(this.conversationId)
+
+                    const logFileInfo = newFileContents.find((file: any) => file.name === RunCommandLogFileName)
+                    if (logFileInfo) {
+                        const filePath = `${this.config.workspaceRoots[0]}/${RunCommandLogFileName}`
+                        const fileUri = vscode.Uri.file(filePath)
+
+                        const fileExists = await fs
+                            .stat(fileUri)
+                            .then(() => true)
+                            .catch(() => false)
+
+                        if (fileExists) {
+                            const fileContent = await fs.readFile(fileUri)
+                            const decodedContent = new TextDecoder().decode(fileContent)
+                            logFileInfo.content = decodedContent + logFileInfo.content
+                        } else {
+                            await fs.writeFile(fileUri, new TextEncoder().encode(logFileInfo.content), {
+                                create: true,
+                                overwrite: true,
+                            })
+                        }
+                        newFileContents.splice(newFileContents.indexOf(logFileInfo), 1)
+                    }
+
                     const newFileInfo = registerNewFiles(
                         fs,
                         newFileContents,

packages/core/src/test/amazonqDoc/session/sessionState.test.ts

@@ -10,6 +10,7 @@ import { DocPrepareCodeGenState } from '../../../amazonqDoc'
 import { createMockSessionStateAction } from '../../amazonq/utils'
 
 import { createTestContext, setupTestHooks } from '../../amazonq/session/testSetup'
+const filesModule = require('../../../amazonq/util/files')
 
 describe('sessionStateDoc', () => {
     const context = createTestContext()
@@ -27,3 +28,179 @@ describe('sessionStateDoc', () => {
         })
     })
 })
+
+describe('CodeGenBase generateCode log file handling', () => {
+    const RunCommandLogFileName = '.amazonq/dev/run_command.log'
+
+    const registerNewFilesStub = sinon.stub()
+    registerNewFilesStub.callsFake((fs: any, newFileContents: any[]) => {
+        return newFileContents
+    })
+    const getDeletedFileInfosStub = sinon.stub()
+    getDeletedFileInfosStub.callsFake((fs: any, deletedFiles: any[]) => {
+        return []
+    })
+
+    class TestCodeGen extends (require('../../../amazonq/session/sessionState') as any).CodeGenBase {
+        public generatedFiles: any[] = []
+        constructor(config: any, tabID: string) {
+            super(config, tabID)
+        }
+        protected handleProgress(messenger: any, action: any, detail?: string): void {
+            // no-op
+        }
+        protected getScheme(): string {
+            return 'file'
+        }
+        protected getTimeoutErrorCode(): string {
+            return 'test_timeout'
+        }
+        protected handleGenerationComplete(messenger: any, newFileInfo: any[], action: any): void {
+            this.generatedFiles = newFileInfo
+        }
+        protected handleError(messenger: any, codegenResult: any): Error {
+            throw new Error('handleError called')
+        }
+    }
+
+    let testConfig: any
+    let fakeProxyClient: any
+    let fsMock: any
+    let telemetryMock: any
+    let messengerMock: any
+    let testAction: any
+
+    beforeEach(() => {
+        fakeProxyClient = {
+            getCodeGeneration: sinon.stub().resolves({
+                codeGenerationStatus: { status: 'Complete' },
+                codeGenerationRemainingIterationCount: 0,
+                codeGenerationTotalIterationCount: 1,
+            }),
+            exportResultArchive: sinon.stub(),
+        }
+
+        testConfig = {
+            conversationId: 'conv1',
+            uploadId: 'upload1',
+            workspaceRoots: ['/workspace'],
+            proxyClient: fakeProxyClient,
+        }
+
+        fsMock = {
+            stat: sinon.stub(),
+            readFile: sinon.stub(),
+            writeFile: sinon.stub(),
+        }
+
+        telemetryMock = {
+            setCodeGenerationResult: sinon.spy(),
+            setNumberOfFilesGenerated: sinon.spy(),
+            setAmazonqNumberOfReferences: sinon.spy(),
+            setGenerateCodeIteration: sinon.spy(),
+            setGenerateCodeLastInvocationTime: sinon.spy(),
+            recordUserCodeGenerationTelemetry: sinon.spy(),
+        }
+
+        messengerMock = {
+            sendAnswer: sinon.spy(),
+        }
+
+        testAction = {
+            telemetry: telemetryMock,
+            fs: fsMock,
+            messenger: messengerMock,
+            uploadHistory: {},
+            tokenSource: { token: { isCancellationRequested: false, onCancellationRequested: () => {} } },
+        }
+    })
+
+    afterEach(() => {
+        sinon.restore()
+    })
+
+    it('should append existing log file content to new log content and remove the log file entry when file exists', async () => {
+        const logFileInfo = {
+            name: RunCommandLogFileName,
+            content: 'newLog',
+        }
+        const otherFile = { name: 'other.ts', content: 'other' }
+
+        fakeProxyClient.exportResultArchive.resolves({
+            newFileContents: [logFileInfo, otherFile],
+            deletedFiles: [],
+            references: [],
+        })
+
+        fsMock.stat.resolves({})
+        fsMock.readFile.resolves(Buffer.from('existing'))
+
+        sinon.stub(filesModule, 'registerNewFiles').callsFake(registerNewFilesStub)
+        sinon.stub(filesModule, 'getDeletedFileInfos').callsFake(getDeletedFileInfosStub)
+
+        const testCodeGen = new TestCodeGen(testConfig, 'tab1')
+
+        await testCodeGen.generateCode({
+            messenger: messengerMock,
+            fs: fsMock,
+            codeGenerationId: 'codegen1',
+            telemetry: telemetryMock,
+            workspaceFolders: {},
+            action: testAction,
+        })
+
+        const expectedFilePath = `${testConfig.workspaceRoots[0]}/${RunCommandLogFileName}`
+        const fileUri = vscode.Uri.file(expectedFilePath)
+        sinon.assert.calledWith(fsMock.stat, fileUri)
+        sinon.assert.calledWith(fsMock.readFile, fileUri)
+
+        assert.strictEqual(logFileInfo.content, 'existingnewLog')
+        assert.deepStrictEqual(testCodeGen.generatedFiles, [otherFile])
+
+        sinon.restore()
+    })
+
+    it('should create a new log file when log file does not exist', async () => {
+        const logFileInfo = {
+            name: RunCommandLogFileName,
+            content: 'newLog',
+        }
+        const otherFile = { name: 'other.ts', content: 'other' }
+
+        fakeProxyClient.exportResultArchive.resolves({
+            newFileContents: [logFileInfo, otherFile],
+            deletedFiles: [],
+            references: [],
+        })
+
+        fsMock.stat.rejects(new Error('Not found'))
+        fsMock.writeFile.resolves()
+
+        sinon.stub(filesModule, 'registerNewFiles').callsFake(registerNewFilesStub)
+        sinon.stub(filesModule, 'getDeletedFileInfos').callsFake(getDeletedFileInfosStub)
+
+        const testCodeGen = new TestCodeGen(testConfig, 'tab1')
+
+        await testCodeGen.generateCode({
+            messenger: messengerMock,
+            fs: fsMock,
+            codeGenerationId: 'codegen2',
+            telemetry: telemetryMock,
+            workspaceFolders: {},
+            action: testAction,
+        })
+
+        const expectedFilePath = `${testConfig.workspaceRoots[0]}/${RunCommandLogFileName}`
+        const fileUri = vscode.Uri.file(expectedFilePath)
+        sinon.assert.calledWith(fsMock.stat, fileUri)
+        sinon.assert.calledWith(fsMock.writeFile, fileUri, new TextEncoder().encode('newLog'), {
+            create: true,
+            overwrite: true,
+        })
+        sinon.assert.notCalled(fsMock.readFile)
+
+        assert.deepStrictEqual(testCodeGen.generatedFiles, [otherFile])
+
+        sinon.restore()
+    })
+})