feat: implement iteration based guidelines generation from science doc

Author: bywang56

chat-client/src/client/features/rules.test.ts

@@ -148,7 +148,7 @@ describe('rules', () => {
         it('calls messager when create memory bank is clicked', () => {
             const createMemoryBankItem: DetailedListItem = {
                 id: ContextRule.CreateMemoryBankId,
-                description: 'Create Memory Bank',
+                description: 'Generate Memory Bank',
             }
 
             onItemClick(createMemoryBankItem)

chat-client/src/client/features/rules.ts

@@ -87,8 +87,8 @@ export class RulesList {
         // The tabId should be the same as the one used for the rules list
         this.messager.onChatPrompt({
             prompt: {
-                prompt: 'Create a Memory Bank for this project',
-                escapedPrompt: 'Create a Memory Bank for this project',
+                prompt: 'Generate a Memory Bank for this project',
+                escapedPrompt: 'Generate a Memory Bank for this project',
             },
             tabId: this.tabId, // Use the current tab ID
         })
@@ -176,10 +176,36 @@ const createRuleListItem: DetailedListItem = {
     id: ContextRule.CreateRuleId,
 }
 
-const createMemoryBankListItem: DetailedListItem = {
-    description: 'Create Memory Bank',
-    icon: MynahIcons.FOLDER,
-    id: ContextRule.CreateMemoryBankId,
+function createMemoryBankListItem(rules: RulesFolder[]): DetailedListItem {
+    // Check if memory-bank folder exists with files
+    // Look for folder that contains memory bank files (product, structure, tech, guidelines)
+    // Note: Server sends rule names WITHOUT .md extension (e.g., 'product' not 'product.md')
+    const memoryBankFiles = ['product', 'structure', 'tech', 'guidelines']
+
+    console.log('[DEBUG] createMemoryBankListItem called with rules:', JSON.stringify(rules, null, 2))
+
+    // Find memory-bank folder
+    const memoryBankFolder = rules.find(folder => folder.folderName === 'memory-bank')
+    console.log('[DEBUG] Found memory-bank folder:', JSON.stringify(memoryBankFolder, null, 2))
+
+    // Check if any memory bank files exist
+    const hasMemoryBankFiles =
+        memoryBankFolder &&
+        memoryBankFolder.rules.some(rule => {
+            const matches = memoryBankFiles.includes(rule.name)
+            console.log(`[DEBUG] Checking rule "${rule.name}" against memory bank files:`, matches)
+            return matches
+        })
+
+    console.log('[DEBUG] hasMemoryBankFiles result:', hasMemoryBankFiles)
+    const buttonText = hasMemoryBankFiles ? 'Regenerate Memory Bank' : 'Generate Memory Bank'
+    console.log('[DEBUG] Button text will be:', buttonText)
+
+    return {
+        description: buttonText,
+        icon: MynahIcons.FOLDER,
+        id: ContextRule.CreateMemoryBankId,
+    }
 }
 
 export function convertRulesListToDetailedListGroup(rules: RulesFolder[]): DetailedListItemGroup[] {
@@ -207,7 +233,7 @@ export function convertRulesListToDetailedListGroup(rules: RulesFolder[]): Detai
         )
         .concat({
             groupName: 'Actions',
-            children: [createMemoryBankListItem, createRuleListItem],
+            children: [createMemoryBankListItem(rules), createRuleListItem],
         })
 }
 

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

@@ -851,19 +851,77 @@ export class AgenticChatController implements ChatHandlers {
 
         IdleWorkspaceManager.recordActivityTimestamp()
 
-        // Memory Bank Creation Flow - Step 1: First 3 Files Only
+        // Memory Bank Creation Flow - Delegate everything to MemoryBankController
         if (this.#memoryBankController.isMemoryBankCreationRequest(params.prompt.prompt)) {
             this.#features.logging.info(`[Memory Bank] Detected memory bank request for tabId: ${params.tabId}`)
 
-            // Step 1: Create first 3 files using standard agent analysis
-            params.prompt.prompt = this.#memoryBankController.getFirst3FilesPrompt()
+            // Delegate the entire workflow to MemoryBankController
+            const workspaceFolders = workspaceUtils.getWorkspaceFolderPaths(this.#features.workspace)
+            const workspaceUri = workspaceFolders.length > 0 ? workspaceFolders[0] : ''
+            params.prompt.prompt = await this.#memoryBankController.prepareComprehensiveMemoryBankPrompt(
+                workspaceUri,
+                async (message: string) => {
+                    await this.#features.chat.sendChatUpdate({
+                        tabId: params.tabId,
+                        data: {
+                            messages: [
+                                {
+                                    messageId: `memory-bank-status-${Date.now()}`,
+                                    body: message,
+                                },
+                            ],
+                        },
+                    })
+                },
+                async (prompt: string) => {
+                    // Direct LLM call for ranking - no agentic loop, just a simple API call
+                    this.#features.logging.info(`[Memory Bank] Making direct LLM call for file ranking`)
 
-            this.#features.logging.info(
-                `[Memory Bank] Step 1: Creating first 3 memory bank files (product.md, structure.md, tech.md)`
+                    try {
+                        if (!this.#serviceManager) {
+                            throw new Error('amazonQServiceManager is not initialized')
+                        }
+
+                        const client = this.#serviceManager.getStreamingClient()
+
+                        // Create a simple message request for ranking
+                        const requestInput: SendMessageCommandInput = {
+                            conversationState: {
+                                chatTriggerType: ChatTriggerType.MANUAL,
+                                currentMessage: {
+                                    userInputMessage: {
+                                        content: prompt,
+                                    },
+                                },
+                            },
+                        }
+
+                        this.#features.logging.info(`[Memory Bank] Sending ranking request to LLM`)
+                        const response = await client.sendMessage(requestInput)
+
+                        // Extract the response content from the streaming response
+                        let responseContent = ''
+                        if (response.sendMessageResponse) {
+                            for await (const chatEvent of response.sendMessageResponse) {
+                                if (chatEvent.assistantResponseEvent?.content) {
+                                    responseContent += chatEvent.assistantResponseEvent.content
+                                }
+                            }
+                        }
+
+                        this.#features.logging.info(
+                            `[Memory Bank] LLM ranking response received: ${responseContent.length} characters`
+                        )
+                        return responseContent.trim()
+                    } catch (error) {
+                        this.#features.logging.error(`[Memory Bank] LLM ranking failed: ${error}`)
+                        this.#features.logging.info(`[Memory Bank] Falling back to TF-IDF ranking`)
+                        return '' // Empty string triggers TF-IDF fallback
+                    }
+                }
             )
 
-            // Mark this session for memory bank completion detection
-            this.#markSessionForMemoryBankCompletion(params.tabId)
+            this.#features.logging.info(`[Memory Bank] Starting comprehensive memory bank creation`)
         }
 
         const maybeDefaultResponse = !params.prompt.command && getDefaultChatResponse(params.prompt.prompt)
@@ -942,7 +1000,8 @@ export class AgenticChatController implements ChatHandlers {
             const additionalContext = await this.#additionalContextProvider.getAdditionalContext(
                 triggerContext,
                 params.tabId,
-                params.context
+                params.context,
+                params.prompt.prompt
             )
             // Add active file to context list if it's not already there
             const activeFile =
@@ -4387,10 +4446,7 @@ export class AgenticChatController implements ChatHandlers {
             if (chatEvent.assistantResponseEvent || chatEvent.codeReferenceEvent) {
                 await streamWriter.write(result.data.chatResult)
 
-                // Memory Bank completion detection
-                if (chatEvent.assistantResponseEvent && result.data.chatResult.body) {
-                    await this.#checkMemoryBankCompletion(tabId, result.data.chatResult.body)
-                }
+                // Memory Bank completion detection - removed from here to avoid timing issues
             }
 
             if (chatEvent.toolUseEvent) {
@@ -4418,6 +4474,8 @@ export class AgenticChatController implements ChatHandlers {
         }
         await streamWriter.close()
 
+        // No special completion detection needed - single agentic loop completes naturally
+
         metric.mergeWith({
             cwsprChatFullResponseLatency: metric.getTimeElapsed(),
             cwsprChatFollowUpCount: chatEventParser.totalEvents.followupPromptEvent,
@@ -4749,94 +4807,7 @@ export class AgenticChatController implements ChatHandlers {
         return value
     }
 
-    // Memory Bank Completion Detection
-    #memoryBankPendingSessions = new Set<string>()
-
-    /**
-     * Mark a session for memory bank completion detection
-     */
-    #markSessionForMemoryBankCompletion(tabId: string): void {
-        this.#memoryBankPendingSessions.add(tabId)
-        this.#features.logging.info(`[Memory Bank] Marked session ${tabId} for completion detection`)
-    }
-
-    /**
-     * Check if a session is pending memory bank completion
-     */
-    #isMemoryBankPendingCompletion(tabId: string): boolean {
-        return this.#memoryBankPendingSessions.has(tabId)
-    }
-
-    /**
-     * Detect memory bank completion and trigger guidelines generation
-     */
-    async #checkMemoryBankCompletion(tabId: string, messageContent: string): Promise<void> {
-        if (!this.#isMemoryBankPendingCompletion(tabId)) {
-            return
-        }
-
-        // Check if the agent has completed creating the first 3 files
-        const completionIndicators = [
-            'product.md',
-            'structure.md',
-            'tech.md',
-            'memory bank',
-            'created successfully',
-            'files have been created',
-        ]
-
-        const hasCompletionIndicators = completionIndicators.some(indicator =>
-            messageContent.toLowerCase().includes(indicator.toLowerCase())
-        )
-
-        if (hasCompletionIndicators) {
-            this.#features.logging.info(`[Memory Bank] Step 1 completion detected for session ${tabId}`)
-
-            // Remove from pending set
-            this.#memoryBankPendingSessions.delete(tabId)
-
-            // Trigger Steps 2-5: Guidelines generation
-            await this.#triggerGuidelinesGeneration(tabId)
-        }
-    }
-
-    /**
-     * Trigger guidelines.md generation (Steps 2-5)
-     */
-    async #triggerGuidelinesGeneration(tabId: string): Promise<void> {
-        try {
-            this.#features.logging.info(`[Memory Bank] Starting guidelines generation for session ${tabId}`)
+    // Memory Bank logic moved to MemoryBankController
 
-            // Get workspace folder URI - use empty string as default for root workspace
-            const workspaceFolderUri = ''
-
-            // Create LLM call function that uses the chat system
-            const llmCallFunction = async (prompt: string): Promise<string> => {
-                // TODO: Implement actual LLM call using the chat system
-                // For now, return a placeholder response
-                return 'LLM response placeholder'
-            }
-
-            // Delegate all complex logic to MemoryBankController
-            const result = await this.#memoryBankController.executeCompleteMemoryBankCreationWithLLM(
-                workspaceFolderUri,
-                llmCallFunction
-            )
-
-            // Send message to chat
-            await this.#features.chat.sendChatUpdate({
-                tabId,
-                data: {
-                    messages: [
-                        {
-                            messageId: `memory-bank-complete-${Date.now()}`,
-                            body: result.message,
-                        },
-                    ],
-                },
-            })
-        } catch (error) {
-            this.#features.logging.error(`[Memory Bank] Error in guidelines generation: ${error}`)
-        }
-    }
+    // All Memory Bank methods moved to MemoryBankController and MemoryBankPrompts
 }

server/aws-lsp-codewhisperer/src/language-server/agenticChat/context/additionalContextProvider.ts

@@ -33,6 +33,7 @@ import { ChatDatabase } from '../tools/chatDb/chatDb'
 import { ChatMessage, ImageBlock, ImageFormat } from '@amzn/codewhisperer-streaming'
 import { getRelativePathWithUri, getRelativePathWithWorkspaceFolder } from '../../workspaceContext/util'
 import { isSupportedImageExtension, MAX_IMAGE_CONTEXT_COUNT } from '../../../shared/imageVerification'
+import { MemoryBankController } from './memorybank/memoryBankController'
 import { mergeFileLists } from './contextUtils'
 
 export const ACTIVE_EDITOR_CONTEXT_ID = 'active-editor'
@@ -229,7 +230,8 @@ export class AdditionalContextProvider {
     async getAdditionalContext(
         triggerContext: TriggerContext,
         tabId: string,
-        context?: ContextCommand[]
+        context?: ContextCommand[],
+        prompt?: string
     ): Promise<AdditionalContentEntryAddition[]> {
         triggerContext.contextInfo = getInitialContextInfo()
 
@@ -250,21 +252,43 @@ export class AdditionalContextProvider {
             : workspaceUtils.getWorkspaceFolderPaths(this.features.workspace)[0]
 
         if (workspaceRules.length > 0) {
-            // ALL workspace rules (including memory bank files) go to pinnedContextCommands
-            // This follows the same pattern as regular rules - they go to conversation history
-            pinnedContextCommands.push(...workspaceRules)
-
-            // Log memory bank files being included in chat context for verification
-            const memoryBankFiles = workspaceRules.filter(rule => rule.id?.includes('memory-bank'))
-            if (memoryBankFiles.length > 0) {
-                this.features.logging.info(
-                    `[Memory Bank] Including ${memoryBankFiles.length} memory bank files in chat context for tabId: ${tabId}`
-                )
-                memoryBankFiles.forEach(file => {
-                    const fileName = path.basename(file.id)
-                    this.features.logging.info(`[Memory Bank] - Including: ${fileName} (${file.id})`)
-                })
+            // Check if this is a memory bank generation request
+            const isMemoryBankRequest = prompt
+                ? new MemoryBankController(this.features).isMemoryBankCreationRequest(prompt)
+                : false
+
+            let rulesToInclude = workspaceRules
+
+            if (isMemoryBankRequest) {
+                // Exclude memory bank files from context when generating memory bank
+                const memoryBankFiles = workspaceRules.filter(rule => rule.id?.includes('memory-bank'))
+                rulesToInclude = workspaceRules.filter(rule => !rule.id?.includes('memory-bank'))
+
+                if (memoryBankFiles.length > 0) {
+                    this.features.logging.info(
+                        `[Memory Bank] Excluding ${memoryBankFiles.length} existing memory bank files from context for regeneration`
+                    )
+                    memoryBankFiles.forEach(file => {
+                        const fileName = path.basename(file.id)
+                        this.features.logging.info(`[Memory Bank] - Excluding: ${fileName} (${file.id})`)
+                    })
+                }
+            } else {
+                // Normal behavior: include all workspace rules (including memory bank files)
+                const memoryBankFiles = workspaceRules.filter(rule => rule.id?.includes('memory-bank'))
+                if (memoryBankFiles.length > 0) {
+                    this.features.logging.info(
+                        `[Memory Bank] Including ${memoryBankFiles.length} memory bank files in chat context for tabId: ${tabId}`
+                    )
+                    memoryBankFiles.forEach(file => {
+                        const fileName = path.basename(file.id)
+                        this.features.logging.info(`[Memory Bank] - Including: ${fileName} (${file.id})`)
+                    })
+                }
             }
+
+            // Add the filtered rules to pinned context
+            pinnedContextCommands.push(...rulesToInclude)
         }
 
         // Merge pinned context with context added to prompt, avoiding duplicates
@@ -700,6 +724,8 @@ export class AdditionalContextProvider {
     }
 
     convertRulesToRulesFolders(workspaceRules: ContextCommandItem[], tabId: string): RulesFolder[] {
+        this.features.logging.info(`[DEBUG] convertRulesToRulesFolders called with ${workspaceRules.length} rules`)
+
         // Check if there's only one workspace folder
         const workspaceFolders = workspaceUtils.getWorkspaceFolderPaths(this.features.workspace)
         const isSingleWorkspace = workspaceFolders.length <= 1
@@ -719,7 +745,9 @@ export class AdditionalContextProvider {
                 if (dirPath === '.') {
                     folderName = undefined
                 } else {
-                    folderName = dirPath
+                    // Use only the last part of the directory path for display
+                    // e.g., ".amazonq/rules/memory-bank" becomes "memory-bank"
+                    folderName = path.basename(dirPath)
                 }
             } else {
                 // In multi-workspace: include workspace folder name for all files
@@ -805,6 +833,8 @@ export class AdditionalContextProvider {
             return a.folderName.localeCompare(b.folderName)
         })
 
+        this.features.logging.info(`[DEBUG] Final rulesFolders structure: ${JSON.stringify(rulesFolders, null, 2)}`)
+
         return rulesFolders
     }