fix(amazonq): handle case where multiple rules are provided with the same name (aws#2118)

* fix(amazonq): handle case where multiple rules are provided with the same name

* fix(amazonq): add unit test for duplicate custom guidelines

* fix(amazonq): add unit test for processToolUses

* fix(amazonq): set context type for AmazonQ.md to rule

* fix(amazonq): add README.md back as rule context type

---------

Co-authored-by: Blake Lazarine <[email protected]>

Author: BlakeLazarine

server/aws-lsp-codewhisperer/src/language-server/agenticChat/agenticChatController.test.ts

@@ -241,7 +241,7 @@ describe('AgenticChatController', () => {
         testFeatures.agent = {
             runTool: sinon.stub().resolves({}),
             getTools: sinon.stub().returns(
-                ['mock-tool-name', 'mock-tool-name-1', 'mock-tool-name-2'].map(toolName => ({
+                ['mock-tool-name', 'mock-tool-name-1', 'mock-tool-name-2', 'codeReview'].map(toolName => ({
                     toolSpecification: { name: toolName, description: 'Mock tool for testing' },
                 }))
             ),
@@ -3283,6 +3283,90 @@ ${' '.repeat(8)}}
             assert.strictEqual(returnValue, undefined)
         })
     })
+
+    describe('processToolUses', () => {
+        it('filters rule artifacts from additionalContext for CodeReview tool', async () => {
+            const mockAdditionalContext = [
+                {
+                    type: 'file',
+                    description: '',
+                    name: '',
+                    relativePath: '',
+                    startLine: 0,
+                    endLine: 0,
+                    path: '/test/file.js',
+                },
+                {
+                    type: 'rule',
+                    description: '',
+                    name: '',
+                    relativePath: '',
+                    startLine: 0,
+                    endLine: 0,
+                    path: '/test/rule1.json',
+                },
+                {
+                    type: 'rule',
+                    description: '',
+                    name: '',
+                    relativePath: '',
+                    startLine: 0,
+                    endLine: 0,
+                    path: '/test/rule2.json',
+                },
+            ]
+
+            const toolUse = {
+                toolUseId: 'test-id',
+                name: 'codeReview',
+                input: { fileLevelArtifacts: [{ path: '/test/file.js' }] },
+                stop: true,
+            }
+
+            const runToolStub = testFeatures.agent.runTool as sinon.SinonStub
+            runToolStub.resolves({})
+
+            // Create a mock session with toolUseLookup
+            const mockSession = {
+                toolUseLookup: new Map(),
+                pairProgrammingMode: true,
+            } as any
+
+            // Create a minimal mock of AgenticChatResultStream
+            const mockChatResultStream = {
+                removeResultBlockAndUpdateUI: sinon.stub().resolves(),
+                writeResultBlock: sinon.stub().resolves(1),
+                overwriteResultBlock: sinon.stub().resolves(),
+                removeResultBlock: sinon.stub().resolves(),
+                getMessageBlockId: sinon.stub().returns(undefined),
+                hasMessage: sinon.stub().returns(false),
+                updateOngoingProgressResult: sinon.stub().resolves(),
+                getResult: sinon.stub().returns({ messageId: 'test', body: '' }),
+                setMessageIdToUpdateForTool: sinon.stub(),
+                getMessageIdToUpdateForTool: sinon.stub().returns(undefined),
+                addMessageOperation: sinon.stub(),
+                getMessageOperation: sinon.stub().returns(undefined),
+            }
+
+            // Call processToolUses directly
+            await chatController.processToolUses(
+                [toolUse],
+                mockChatResultStream as any,
+                mockSession,
+                'tabId',
+                mockCancellationToken,
+                mockAdditionalContext
+            )
+
+            // Verify runTool was called with ruleArtifacts
+            sinon.assert.calledOnce(runToolStub)
+            const toolInput = runToolStub.firstCall.args[1]
+            assert.ok(toolInput.ruleArtifacts)
+            assert.strictEqual(toolInput.ruleArtifacts.length, 2)
+            assert.strictEqual(toolInput.ruleArtifacts[0].path, '/test/rule1.json')
+            assert.strictEqual(toolInput.ruleArtifacts[1].path, '/test/rule2.json')
+        })
+    })
 })
 
 // The body may include text-based progress updates from tool invocations.

server/aws-lsp-codewhisperer/src/language-server/agenticChat/agenticChatController.ts

@@ -1387,7 +1387,14 @@ export class AgenticChatController implements ChatHandlers {
             session.setConversationType('AgenticChatWithToolUse')
             if (result.success) {
                 // Process tool uses and update the request input for the next iteration
-                toolResults = await this.#processToolUses(pendingToolUses, chatResultStream, session, tabId, token)
+                toolResults = await this.processToolUses(
+                    pendingToolUses,
+                    chatResultStream,
+                    session,
+                    tabId,
+                    token,
+                    additionalContext
+                )
                 if (toolResults.some(toolResult => this.#shouldSendBackErrorContent(toolResult))) {
                     content = 'There was an error processing one or more tool uses. Try again, do not apologize.'
                     shouldDisplayMessage = false
@@ -1662,12 +1669,13 @@ export class AgenticChatController implements ChatHandlers {
     /**
      * Processes tool uses by running the tools and collecting results
      */
-    async #processToolUses(
+    async processToolUses(
         toolUses: Array<ToolUse & { stop: boolean }>,
         chatResultStream: AgenticChatResultStream,
         session: ChatSessionService,
         tabId: string,
-        token?: CancellationToken
+        token?: CancellationToken,
+        additionalContext?: AdditionalContentEntryAddition[]
     ): Promise<ToolResult[]> {
         const results: ToolResult[] = []
 
@@ -1868,12 +1876,11 @@ export class AgenticChatController implements ChatHandlers {
                 if (toolUse.name === CodeReview.toolName) {
                     try {
                         let initialInput = JSON.parse(JSON.stringify(toolUse.input))
-                        let ruleArtifacts = await this.#additionalContextProvider.collectWorkspaceRules(tabId)
-                        if (ruleArtifacts !== undefined || ruleArtifacts !== null) {
-                            this.#features.logging.info(`RuleArtifacts: ${JSON.stringify(ruleArtifacts)}`)
-                            let pathsToRulesMap = ruleArtifacts.map(ruleArtifact => ({ path: ruleArtifact.id }))
-                            this.#features.logging.info(`PathsToRules: ${JSON.stringify(pathsToRulesMap)}`)
-                            initialInput['ruleArtifacts'] = pathsToRulesMap
+
+                        if (additionalContext !== undefined) {
+                            initialInput['ruleArtifacts'] = additionalContext
+                                .filter(c => c.type === 'rule')
+                                .map(c => ({ path: c.path }))
                         }
                         toolUse.input = initialInput
                     } catch (e) {

server/aws-lsp-codewhisperer/src/language-server/agenticChat/tools/qCodeAnalysis/codeReview.test.ts

@@ -385,6 +385,34 @@ describe('CodeReview', () => {
                 expect(error.message).to.include('There are no valid files to scan')
             }
         })
+
+        it('should handle duplicate rule filenames with unique UUIDs', async () => {
+            const fileArtifacts = [{ path: '/test/file.js' }]
+            const folderArtifacts: any[] = []
+            const ruleArtifacts = [{ path: '/test/path1/rule.json' }, { path: '/test/path2/rule.json' }]
+
+            const mockZip = {
+                file: sandbox.stub(),
+                generateAsync: sandbox.stub().resolves(Buffer.from('test')),
+            }
+            sandbox.stub(JSZip.prototype, 'file').callsFake(mockZip.file)
+            sandbox.stub(JSZip.prototype, 'generateAsync').callsFake(mockZip.generateAsync)
+            sandbox.stub(CodeReviewUtils, 'countZipFiles').returns(3)
+            sandbox.stub(require('crypto'), 'randomUUID').returns('test-uuid-123')
+
+            await (codeReview as any).prepareFilesAndFoldersForUpload(
+                fileArtifacts,
+                folderArtifacts,
+                ruleArtifacts,
+                false
+            )
+
+            // Verify first file uses original name
+            expect(mockZip.file.firstCall.args[0]).to.include('/test/file.js')
+            expect(mockZip.file.secondCall.args[0]).to.include('rule.json')
+            // Verify second file gets UUID suffix
+            expect(mockZip.file.thirdCall.args[0]).to.include('rule_test-uuid-123.json')
+        })
     })
 
     describe('collectFindings', () => {

server/aws-lsp-codewhisperer/src/language-server/agenticChat/tools/qCodeAnalysis/codeReview.ts

@@ -716,6 +716,7 @@ export class CodeReview {
      * @param customerCodeZip JSZip instance for the customer code
      */
     private async processRuleArtifacts(ruleArtifacts: RuleArtifacts, customerCodeZip: JSZip): Promise<void> {
+        let ruleNameSet = new Set<string>()
         for (const artifact of ruleArtifacts) {
             await CodeReviewUtils.withErrorHandling(
                 async () => {
@@ -725,6 +726,10 @@ export class CodeReview {
                         !CodeReviewUtils.shouldSkipFile(fileName) &&
                         existsSync(artifact.path)
                     ) {
+                        if (ruleNameSet.has(fileName)) {
+                            fileName = fileName.split('.')[0] + '_' + crypto.randomUUID() + '.' + fileName.split('.')[1]
+                        }
+                        ruleNameSet.add(fileName)
                         const fileContent = await this.workspace.fs.readFile(artifact.path)
                         customerCodeZip.file(
                             `${CodeReview.CUSTOMER_CODE_BASE_PATH}/${CodeReview.RULE_ARTIFACT_PATH}/${fileName}`,