Merge master into feature/auto-debug

Author: aws-toolkit-automation

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

@@ -8,6 +8,7 @@ import { LanguageClient } from 'vscode-languageclient'
 import { getLogger } from 'aws-core-vscode/shared'
 import { globals } from 'aws-core-vscode/shared'
 import { AmazonQInlineCompletionItemProvider } from './completion'
+import { CodeSuggestionsState } from 'aws-core-vscode/codewhisperer'
 
 // Configuration section for cursor updates
 export const cursorUpdateConfigurationSection = 'aws.q.cursorUpdate'
@@ -32,11 +33,23 @@ export class CursorUpdateManager implements vscode.Disposable, ICursorUpdateReco
     private lastSentDocumentUri?: string
     private isActive = false
     private lastRequestTime = 0
+    private autotriggerStateDisposable?: vscode.Disposable
 
     constructor(
         private readonly languageClient: LanguageClient,
         private readonly inlineCompletionProvider?: AmazonQInlineCompletionItemProvider
-    ) {}
+    ) {
+        // Listen for autotrigger state changes to enable/disable the timer
+        this.autotriggerStateDisposable = CodeSuggestionsState.instance.onDidChangeState((isEnabled: boolean) => {
+            if (isEnabled && this.isActive) {
+                // If autotrigger is enabled and we're active, ensure timer is running
+                this.setupUpdateTimer()
+            } else {
+                // If autotrigger is disabled, clear the timer but keep isActive state
+                this.clearUpdateTimer()
+            }
+        })
+    }
 
     /**
      * Start tracking cursor positions and sending periodic updates
@@ -66,7 +79,9 @@ export class CursorUpdateManager implements vscode.Disposable, ICursorUpdateReco
         }
 
         this.isActive = true
-        this.setupUpdateTimer()
+        if (CodeSuggestionsState.instance.isSuggestionsEnabled()) {
+            this.setupUpdateTimer()
+        }
     }
 
     /**
@@ -130,7 +145,7 @@ export class CursorUpdateManager implements vscode.Disposable, ICursorUpdateReco
     }
 
     /**
-     * Send a cursor position update to the language server
+     * Request LSP generate a completion for the current cursor position.
      */
     private async sendCursorUpdate(): Promise<void> {
         // Don't send an update if a regular request was made recently
@@ -185,6 +200,12 @@ export class CursorUpdateManager implements vscode.Disposable, ICursorUpdateReco
      * Dispose of resources
      */
     public dispose(): void {
+        // Dispose of the autotrigger state change listener
+        if (this.autotriggerStateDisposable) {
+            this.autotriggerStateDisposable.dispose()
+            this.autotriggerStateDisposable = undefined
+        }
+
         this.stop()
     }
 }

packages/amazonq/test/unit/app/inline/cursorUpdateManager.test.ts

@@ -10,6 +10,7 @@ import { CursorUpdateManager } from '../../../../src/app/inline/cursorUpdateMana
 import { globals } from 'aws-core-vscode/shared'
 import assert from 'assert'
 import { AmazonQInlineCompletionItemProvider } from '../../../../src/app/inline/completion'
+import { CodeSuggestionsState } from 'aws-core-vscode/codewhisperer'
 
 describe('CursorUpdateManager', () => {
     let cursorUpdateManager: CursorUpdateManager
@@ -236,4 +237,93 @@ describe('CursorUpdateManager', () => {
         // Verify the provider was called again
         assert.strictEqual(provideStub.callCount, 1, 'Update should be sent when position has changed')
     })
+
+    describe('autotrigger state handling', () => {
+        class TestCodeSuggestionsState extends CodeSuggestionsState {
+            private _isEnabled: boolean
+            private _onDidChangeStateEmitter = new vscode.EventEmitter<boolean>()
+
+            public constructor(initialState: boolean = true) {
+                super(initialState)
+                this._isEnabled = initialState
+            }
+
+            public override onDidChangeState = this._onDidChangeStateEmitter.event
+
+            public override isSuggestionsEnabled(): boolean {
+                return this._isEnabled
+            }
+
+            public override async setSuggestionsEnabled(enabled: boolean): Promise<void> {
+                if (this._isEnabled !== enabled) {
+                    this._isEnabled = enabled
+                    this._onDidChangeStateEmitter.fire(enabled)
+                }
+            }
+        }
+
+        let testCodeSuggestionsState: TestCodeSuggestionsState
+        let instanceStub: sinon.SinonStub
+        let testCursorUpdateManager: CursorUpdateManager
+
+        beforeEach(() => {
+            // Create test instance
+            testCodeSuggestionsState = new TestCodeSuggestionsState(true)
+
+            // Stub the static getter to return our test instance
+            instanceStub = sinon.stub(CodeSuggestionsState, 'instance').get(() => testCodeSuggestionsState)
+
+            // Create the manager AFTER the stub is in place so it uses the test instance
+            const mockInlineCompletionProvider = {
+                provideInlineCompletionItems: sinon.stub().resolves([]),
+            } as unknown as AmazonQInlineCompletionItemProvider
+            testCursorUpdateManager = new CursorUpdateManager(languageClient, mockInlineCompletionProvider)
+        })
+
+        afterEach(() => {
+            // Dispose the test manager
+            testCursorUpdateManager.dispose()
+            // Restore the original getter
+            instanceStub.restore()
+        })
+
+        it('should not start timer when autotrigger is disabled', async () => {
+            // Test the new behavior: timer doesn't start when autotrigger is disabled
+            await testCodeSuggestionsState.setSuggestionsEnabled(false)
+            sendRequestStub.resolves({})
+
+            await testCursorUpdateManager.start()
+
+            // Manager should be active but timer should not be started
+            assert.strictEqual((testCursorUpdateManager as any).isActive, true)
+            assert.ok(!setIntervalStub.called, 'Timer should NOT be started when autotrigger is disabled')
+        })
+
+        it('should start/stop timer when autotrigger state changes', async () => {
+            // Start with autotrigger enabled
+            await testCodeSuggestionsState.setSuggestionsEnabled(true)
+            sendRequestStub.resolves({})
+            await testCursorUpdateManager.start()
+
+            // Reset stubs to test state changes
+            setIntervalStub.resetHistory()
+            clearIntervalStub.resetHistory()
+
+            // Simulate autotrigger being disabled
+            await testCodeSuggestionsState.setSuggestionsEnabled(false)
+            assert.ok(clearIntervalStub.called, 'Timer should be stopped when autotrigger is disabled')
+
+            // Simulate autotrigger being enabled again
+            await testCodeSuggestionsState.setSuggestionsEnabled(true)
+            assert.ok(setIntervalStub.called, 'Timer should be started when autotrigger is re-enabled')
+        })
+
+        it('should dispose autotrigger state listener on dispose', () => {
+            testCursorUpdateManager.dispose()
+            // The dispose method should clean up the state listener
+            // We can't easily test the disposal without more complex mocking,
+            // but we can at least verify dispose doesn't throw
+            assert.ok(true, 'Dispose should complete without errors')
+        })
+    })
 })