private initializeFollowUps()

in packages/core/src/amazonqDoc/controllers/chat/controller.ts [223:342]
92 lines of code
18 McCabe index (conditional complexity)

    private initializeFollowUps(): void {
        this.chatControllerMessageListeners.followUpClicked.event(async (data) => {
            const session: Session = await this.sessionStorage.getSession(data.tabID)
            const docGenerationTask = this.docGenerationTasks.getTask(data.tabID)

            const workspaceFolders = vscode.workspace.workspaceFolders
            if (workspaceFolders === undefined || workspaceFolders.length === 0) {
                return
            }

            const workspaceFolderName = vscode.workspace.workspaceFolders?.[0].name || ''

            const authState = await AuthUtil.instance.getChatAuthState()

            if (authState.amazonQ !== 'connected') {
                await this.messenger.sendAuthNeededExceptionMessage(authState, data.tabID)
                session.isAuthenticating = true
                return
            }

            const sendFolderConfirmationMessage = (message: string) => {
                this.messenger.sendFolderConfirmationMessage(
                    data.tabID,
                    message,
                    workspaceFolderName,
                    FolderSelectorFollowUps
                )
            }

            switch (data.followUp.type) {
                case FollowUpTypes.Retry:
                    if (docGenerationTask.mode === Mode.EDIT) {
                        this.enableUserInput(data?.tabID)
                    } else {
                        await this.tabOpened(data)
                    }
                    break
                case FollowUpTypes.NewTask:
                    this.messenger.sendAnswer({
                        type: 'answer',
                        tabID: data?.tabID,
                        message: i18n('AWS.amazonq.featureDev.answer.newTaskChanges'),
                        disableChatInput: true,
                    })
                    return this.newTask(data)
                case FollowUpTypes.CloseSession:
                    return this.closeSession(data)
                case FollowUpTypes.CreateDocumentation:
                    docGenerationTask.interactionType = 'GENERATE_README'
                    docGenerationTask.mode = Mode.CREATE
                    sendFolderConfirmationMessage(i18n('AWS.amazonq.doc.answer.createReadme'))
                    break
                case FollowUpTypes.ChooseFolder:
                    await this.folderSelector(data)
                    break
                case FollowUpTypes.SynchronizeDocumentation:
                    docGenerationTask.mode = Mode.SYNC
                    sendFolderConfirmationMessage(i18n('AWS.amazonq.doc.answer.updateReadme'))
                    break
                case FollowUpTypes.UpdateDocumentation:
                    docGenerationTask.interactionType = 'UPDATE_README'
                    this.messenger.sendAnswer({
                        type: 'answer',
                        tabID: data?.tabID,
                        followUps: [SynchronizeDocumentation, EditDocumentation],
                        disableChatInput: true,
                    })
                    break
                case FollowUpTypes.EditDocumentation:
                    docGenerationTask.interactionType = 'EDIT_README'
                    docGenerationTask.mode = Mode.EDIT
                    sendFolderConfirmationMessage(i18n('AWS.amazonq.doc.answer.updateReadme'))
                    break
                case FollowUpTypes.MakeChanges:
                    docGenerationTask.mode = Mode.EDIT
                    this.enableUserInput(data.tabID)
                    break
                case FollowUpTypes.AcceptChanges:
                    docGenerationTask.userDecision = 'ACCEPT'
                    await this.sendDocAcceptanceEvent(data)
                    await this.insertCode(data)
                    return
                case FollowUpTypes.RejectChanges:
                    docGenerationTask.userDecision = 'REJECT'
                    await this.sendDocAcceptanceEvent(data)
                    this.messenger.sendAnswer({
                        type: 'answer',
                        tabID: data?.tabID,
                        disableChatInput: true,
                        message: 'Your changes have been discarded.',
                        followUps: NewSessionFollowUps,
                    })
                    break
                case FollowUpTypes.ProceedFolderSelection:
                    // If a user did not change the folder in a multi-root workspace, default to the first workspace folder
                    if (docGenerationTask.folderPath === '' && isMultiRootWorkspace()) {
                        docGenerationTask.folderPath = workspaceFolderName
                    }
                    if (docGenerationTask.mode === Mode.EDIT) {
                        this.enableUserInput(data.tabID)
                    } else {
                        await this.generateDocumentation(
                            {
                                ...data,
                                message:
                                    docGenerationTask.mode === Mode.CREATE
                                        ? 'Create documentation for a specific folder'
                                        : 'Sync documentation',
                            },
                            session,
                            docGenerationTask
                        )
                    }
                    break
                case FollowUpTypes.CancelFolderSelection:
                    docGenerationTask.reset()
                    return this.tabOpened(data)
            }
        })
    }