fix(amazonq): update cursor tracking based on autotrigger setting

Author: floralph

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

@@ -236,4 +236,66 @@ 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', () => {
+        let codeSuggestionsStateStub: sinon.SinonStubbedInstance<any>
+        let onDidChangeStateStub: sinon.SinonStub
+        let mockDisposable: { dispose: sinon.SinonStub }
+
+        beforeEach(() => {
+            // Mock the disposable returned by onDidChangeState
+            mockDisposable = { dispose: sinon.stub() }
+            onDidChangeStateStub = sinon.stub().returns(mockDisposable)
+
+            codeSuggestionsStateStub = {
+                isSuggestionsEnabled: sinon.stub().returns(true),
+                onDidChangeState: onDidChangeStateStub,
+            }
+
+            // Mock the CodeSuggestionsState import
+            const CodeSuggestionsState = require('aws-core-vscode/codewhisperer')
+            sinon.stub(CodeSuggestionsState, 'CodeSuggestionsState').value({
+                instance: codeSuggestionsStateStub,
+            })
+        })
+
+        it('should not start timer when autotrigger is disabled', async () => {
+            // Test the new behavior: timer doesn't start when autotrigger is disabled
+            codeSuggestionsStateStub.isSuggestionsEnabled.returns(false)
+            sendRequestStub.resolves({})
+
+            await cursorUpdateManager.start()
+
+            // Manager should be active but timer should not be started
+            assert.strictEqual((cursorUpdateManager 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
+            codeSuggestionsStateStub.isSuggestionsEnabled.returns(true)
+            sendRequestStub.resolves({})
+            await cursorUpdateManager.start()
+
+            // Get the state change callback
+            const stateChangeCallback = onDidChangeStateStub.firstCall.args[0]
+
+            // Reset stubs to test state changes
+            setIntervalStub.resetHistory()
+            clearIntervalStub.resetHistory()
+
+            // Simulate autotrigger being disabled
+            stateChangeCallback(false)
+            assert.ok(clearIntervalStub.called, 'Timer should be stopped when autotrigger is disabled')
+
+            // Simulate autotrigger being enabled again
+            stateChangeCallback(true)
+            assert.ok(setIntervalStub.called, 'Timer should be started when autotrigger is re-enabled')
+        })
+
+        it('should dispose autotrigger state listener on dispose', () => {
+            cursorUpdateManager.dispose()
+            assert.ok(mockDisposable.dispose.called, 'Autotrigger state listener should be disposed')
+        })
+    })
 })