feat(amazonq): Add language server support for codewhisperer

CONTRIBUTING.md

@@ -427,6 +427,32 @@ Example:
 }
 ```
 
+<a name="amazonqLsp-settings">Overrides specifically for the Amazon Q language server</a> can be set using the `aws.dev.amazonqLsp` setting. This is a JSON object consisting of keys/values required to override language server: `manifestUrl`, `supportedVersions`, `id`, and `path`.
+
+Example:
+
+```json
+"aws.dev.amazonqLsp": {
+    "manifestUrl": "https://custom.url/manifest.json",
+    "supportedVersions": "4.0.0",
+    "id": "AmazonQ",
+    "path": "/custom/path/to/local/lsp/folder",
+}
+```
+
+<a name="amazonqWorkspaceLsp-settings">Overrides specifically for the Amazon Q Workspace Context language server</a> can be set using the `aws.dev.amazonqWorkspaceLsp` setting. This is a JSON object consisting of keys/values required to override language server: `manifestUrl`, `supportedVersions`, `id`, and `path`.
+
+Example:
+
+```json
+"aws.dev.amazonqWorkspaceLsp": {
+    "manifestUrl": "https://custom.url/manifest.json",
+    "supportedVersions": "4.0.0",
+    "id": "AmazonQ",
+    "path": "/custom/path/to/local/lsp/folder",
+}
+```
+
 ### Environment variables
 
 Environment variables can be used to modify the behaviour of VSCode. The following are environment variables that can be used to configure the extension:
@@ -472,6 +498,14 @@ Unlike the user setting overrides, not all of these environment variables have t
 
 -   `__CODEWHISPERER_REGION`: for aws.dev.codewhispererService.region
 -   `__CODEWHISPERER_ENDPOINT`: for aws.dev.codewhispererService.endpoint
+-   `__AMAZONQLSP_MANIFEST_URL`: for aws.dev.amazonqLsp.manifestUrl
+-   `__AMAZONQLSP_SUPPORTED_VERSIONS`: for aws.dev.amazonqLsp.supportedVersions
+-   `__AMAZONQLSP_ID`: for aws.dev.amazonqLsp.id
+-   `__AMAZONQLSP_PATH`: for aws.dev.amazonqWorkspaceLsp.locationOverride
+-   `__AMAZONQWORKSPACELSP_MANIFEST_URL`: for aws.dev.amazonqWorkspaceLsp.manifestUrl
+-   `__AMAZONQWORKSPACELSP_SUPPORTED_VERSIONS`: for aws.dev.amazonqWorkspaceLsp.supportedVersions
+-   `__AMAZONQWORKSPACELSP_ID`: for aws.dev.amazonqWorkspaceLsp.id
+-   `__AMAZONQWORKSPACELSP_PATH`: for aws.dev.amazonqWorkspaceLsp.locationOverride
 
 #### Lambda
 

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

@@ -14,6 +14,7 @@
             "env": {
                 "SSMDOCUMENT_LANGUAGESERVER_PORT": "6010",
                 "WEBPACK_DEVELOPER_SERVER": "http://localhost:8080"
+                // "__AMAZONQLSP_LOCATION_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"],
@@ -135,6 +136,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)
+                })
+            })
+        )
+    }
+}