feat(amazonq): Add language server support for codewhisperer

docs/lsp-debugging.md

@@ -0,0 +1,23 @@
+## Language Server Debugging
+
+1. Clone https://github.com/aws/language-servers.git and set it up in the same workspace as this project
+
+    e.g.
+
+    ```
+    /aws-toolkit-vscode
+    /toolkit
+    /core
+    /amazonq
+    /language-servers
+    ```
+
+2. Inside of the language-servers project run:
+    ```
+    npm install
+    npm run compile
+    npm run package
+    ```
+    to get the project setup
+3. Uncomment the `AWS_LANGUAGE_SERVER_OVERRIDE` variable in `amazonq/.vscode/launch.json` Extension configuration
+4. Use the `Launch LSP with Debugging` configuration and set breakpoints in VSCode or the language server

packages/amazonq/.vscode/launch.json

@@ -19,6 +19,7 @@
             "env": {
                 "SSMDOCUMENT_LANGUAGESERVER_PORT": "6010",
                 "WEBPACK_DEVELOPER_SERVER": "http://localhost:8080"
+                // "AWS_LANGUAGE_SERVER_OVERRIDE": "${workspaceFolder}/../../../language-servers/app/aws-lsp-codewhisperer-runtimes/out/token-standalone.js",
             },
             "envFile": "${workspaceFolder}/.local.env",
             "outFiles": ["${workspaceFolder}/dist/**/*.js", "${workspaceFolder}/../core/dist/**/*.js"],
@@ -140,6 +141,31 @@
                 "group": "4_E2ETestCurrentFile",
                 "order": 2
             }
+        },
+        {
+            "name": "Attach to Language Server",
+            "type": "node",
+            "request": "attach",
+            "port": 6080, // Hard defined in core/src/shared/lsp/platform.ts
+            "outFiles": ["${workspaceFolder}/../../../language-servers/**/out/**/*.js"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "${workspaceFolder}/../../../language-servers/**/node_modules/**/*.js"
+            ],
+            "restart": {
+                "maxAttempts": 10,
+                "delay": 1000
+            }
+        }
+    ],
+    "compounds": [
+        {
+            "name": "Launch LSP with Debugging",
+            "configurations": ["Extension", "Attach to Language Server"],
+            "presentation": {
+                "group": "1_Extension",
+                "order": 5
+            }
         }
     ]
 }

packages/amazonq/src/app/inline/activation.ts

@@ -0,0 +1,124 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import vscode from 'vscode'
+import {
+    AuthUtil,
+    CodeSuggestionsState,
+    CodeWhispererCodeCoverageTracker,
+    CodeWhispererConstants,
+    CodeWhispererSettings,
+    ConfigurationEntry,
+    DefaultCodeWhispererClient,
+    invokeRecommendation,
+    isInlineCompletionEnabled,
+    KeyStrokeHandler,
+    RecommendationHandler,
+    runtimeLanguageContext,
+    TelemetryHelper,
+    UserWrittenCodeTracker,
+    vsCodeState,
+} from 'aws-core-vscode/codewhisperer'
+import { Commands, getLogger, globals, sleep } from 'aws-core-vscode/shared'
+
+export async function activate() {
+    const codewhispererSettings = CodeWhispererSettings.instance
+    const client = new DefaultCodeWhispererClient()
+
+    if (isInlineCompletionEnabled()) {
+        await setSubscriptionsforInlineCompletion()
+        await AuthUtil.instance.setVscodeContextProps()
+    }
+
+    function getAutoTriggerStatus(): boolean {
+        return CodeSuggestionsState.instance.isSuggestionsEnabled()
+    }
+
+    async function getConfigEntry(): Promise<ConfigurationEntry> {
+        const isShowMethodsEnabled: boolean =
+            vscode.workspace.getConfiguration('editor').get('suggest.showMethods') || false
+        const isAutomatedTriggerEnabled: boolean = getAutoTriggerStatus()
+        const isManualTriggerEnabled: boolean = true
+        const isSuggestionsWithCodeReferencesEnabled = codewhispererSettings.isSuggestionsWithCodeReferencesEnabled()
+
+        // TODO:remove isManualTriggerEnabled
+        return {
+            isShowMethodsEnabled,
+            isManualTriggerEnabled,
+            isAutomatedTriggerEnabled,
+            isSuggestionsWithCodeReferencesEnabled,
+        }
+    }
+
+    async function setSubscriptionsforInlineCompletion() {
+        RecommendationHandler.instance.subscribeSuggestionCommands()
+
+        /**
+         * Automated trigger
+         */
+        globals.context.subscriptions.push(
+            vscode.window.onDidChangeActiveTextEditor(async (editor) => {
+                await RecommendationHandler.instance.onEditorChange()
+            }),
+            vscode.window.onDidChangeWindowState(async (e) => {
+                await RecommendationHandler.instance.onFocusChange()
+            }),
+            vscode.window.onDidChangeTextEditorSelection(async (e) => {
+                await RecommendationHandler.instance.onCursorChange(e)
+            }),
+            vscode.workspace.onDidChangeTextDocument(async (e) => {
+                const editor = vscode.window.activeTextEditor
+                if (!editor) {
+                    return
+                }
+                if (e.document !== editor.document) {
+                    return
+                }
+                if (!runtimeLanguageContext.isLanguageSupported(e.document)) {
+                    return
+                }
+
+                CodeWhispererCodeCoverageTracker.getTracker(e.document.languageId)?.countTotalTokens(e)
+                UserWrittenCodeTracker.instance.onTextDocumentChange(e)
+                /**
+                 * Handle this keystroke event only when
+                 * 1. It is not a backspace
+                 * 2. It is not caused by CodeWhisperer editing
+                 * 3. It is not from undo/redo.
+                 */
+                if (e.contentChanges.length === 0 || vsCodeState.isCodeWhispererEditing) {
+                    return
+                }
+
+                if (vsCodeState.lastUserModificationTime) {
+                    TelemetryHelper.instance.setTimeSinceLastModification(
+                        performance.now() - vsCodeState.lastUserModificationTime
+                    )
+                }
+                vsCodeState.lastUserModificationTime = performance.now()
+                /**
+                 * Important:  Doing this sleep(10) is to make sure
+                 * 1. this event is processed by vs code first
+                 * 2. editor.selection.active has been successfully updated by VS Code
+                 * Then this event can be processed by our code.
+                 */
+                await sleep(CodeWhispererConstants.vsCodeCursorUpdateDelay)
+                if (!RecommendationHandler.instance.isSuggestionVisible()) {
+                    await KeyStrokeHandler.instance.processKeyStroke(e, editor, client, await getConfigEntry())
+                }
+            }),
+            // manual trigger
+            Commands.register({ id: 'aws.amazonq.invokeInlineCompletion', autoconnect: true }, async () => {
+                invokeRecommendation(
+                    vscode.window.activeTextEditor as vscode.TextEditor,
+                    client,
+                    await getConfigEntry()
+                ).catch((e) => {
+                    getLogger().error('invokeRecommendation failed: %s', (e as Error).message)
+                })
+            })
+        )
+    }
+}