async getChatParamsFromTrigger()

in server/aws-lsp-codewhisperer/src/language-server/agenticChat/context/agenticChatTriggerContext.ts [97:215]
102 lines of code
21 McCabe index (conditional complexity)

    async getChatParamsFromTrigger(
        params: ChatParams | InlineChatParams,
        triggerContext: TriggerContext,
        chatTriggerType: ChatTriggerType,
        customizationArn?: string,
        chatResultStream?: AgenticChatResultStream,
        profileArn?: string,
        history: ChatMessage[] = [],
        tools: BedrockTools = [],
        additionalContent?: AdditionalContentEntryAddition[]
    ): Promise<GenerateAssistantResponseCommandInput> {
        const { prompt } = params
        const defaultEditorState = { workspaceFolders: workspaceUtils.getWorkspaceFolderPaths(this.#lsp) }

        const hasWorkspace = 'context' in params ? params.context?.some(c => c.command === '@workspace') : false

        let promptContent = prompt.escapedPrompt ?? prompt.prompt

        // When the user adds @sage context, ** gets prepended and appended to the prompt because of markdown.
        // This intereferes with routing logic thus we need to remove it
        if (promptContent && promptContent.includes('@sage')) {
            promptContent = promptContent.replace(/\*\*@sage\*\*/g, '@sage')
        }

        if (hasWorkspace) {
            promptContent = promptContent?.replace(/^@workspace\/?/, '')
        }

        // Get workspace documents if @workspace is used
        let relevantDocuments = hasWorkspace
            ? await this.#getRelevantDocuments(promptContent ?? '', chatResultStream)
            : []

        const workspaceFileList = mergeRelevantTextDocuments(relevantDocuments)
        triggerContext.documentReference = triggerContext.documentReference
            ? mergeFileLists(triggerContext.documentReference, workspaceFileList)
            : workspaceFileList
        // Process additionalContent items if present
        if (additionalContent) {
            for (const item of additionalContent) {
                // Determine programming language from file extension or type
                let programmingLanguage: ProgrammingLanguage | undefined = undefined

                if (item.relativePath) {
                    const ext = path.extname(item.relativePath).toLowerCase()
                    const language = languageByExtension[ext]

                    if (language) {
                        programmingLanguage = { languageName: language }
                    }
                }

                const filteredType =
                    item.type === 'file'
                        ? ContentType.FILE
                        : item.type === 'rule' || item.type === 'prompt'
                          ? ContentType.PROMPT
                          : item.type === 'code'
                            ? ContentType.CODE
                            : undefined
                // Create the relevant text document
                const relevantTextDocument: RelevantTextDocumentAddition = {
                    text: item.innerContext,
                    path: item.path,
                    relativeFilePath: item.relativePath,
                    programmingLanguage: programmingLanguage,
                    type: filteredType,
                    startLine: item.startLine || -1,
                    endLine: item.endLine || -1,
                }
                relevantDocuments.push(relevantTextDocument)
            }
        }
        const useRelevantDocuments = relevantDocuments.length !== 0

        const data: GenerateAssistantResponseCommandInput = {
            conversationState: {
                chatTriggerType: chatTriggerType,
                currentMessage: {
                    userInputMessage: {
                        content: promptContent,
                        userInputMessageContext:
                            triggerContext.cursorState && triggerContext.relativeFilePath
                                ? {
                                      editorState: {
                                          cursorState: triggerContext.cursorState,
                                          document: {
                                              text: triggerContext.text,
                                              programmingLanguage: triggerContext.programmingLanguage,
                                              relativeFilePath: triggerContext.relativeFilePath,
                                          },
                                          relevantDocuments: useRelevantDocuments ? relevantDocuments : undefined,
                                          useRelevantDocuments: useRelevantDocuments,
                                          ...defaultEditorState,
                                      },
                                      tools,
                                      envState: this.#mapPlatformToEnvState(process.platform),
                                  }
                                : {
                                      tools,
                                      editorState: {
                                          relevantDocuments: useRelevantDocuments ? relevantDocuments : undefined,
                                          useRelevantDocuments: useRelevantDocuments,
                                          ...defaultEditorState,
                                      },
                                      envState: this.#mapPlatformToEnvState(process.platform),
                                  },
                        userIntent: triggerContext.userIntent,
                        origin: 'IDE',
                    },
                },
                customizationArn,
                history,
            },
            profileArn,
        }

        return data
    }