Refactors feedback button visibility logic for markdown AI

Introduces a context key and a tracker to control the visibility of AI feedback buttons in markdown previews based on both feedback context presence and telemetry settings. Streamlines menu conditions, ensuring buttons only appear when feedback is available and telemetry is enabled, improving maintainability and aligning UI with user permissions.

Author: sergeibbb

contributions.json

@@ -149,7 +149,7 @@
 			"menus": {
 				"editor/title": [
 					{
-						"when": "resourceScheme == gitlens-markdown && config.gitlens.telemetry.enabled && activeCustomEditorId == vscode.markdown.preview.editor",
+						"when": "gitlens:markdown:feedback:available && activeCustomEditorId == vscode.markdown.preview.editor",
 						"group": "navigation",
 						"order": 2
 					}
@@ -162,7 +162,7 @@
 			"menus": {
 				"editor/title": [
 					{
-						"when": "resourceScheme == gitlens-markdown && config.gitlens.telemetry.enabled && activeCustomEditorId == vscode.markdown.preview.editor",
+						"when": "gitlens:markdown:feedback:available && activeCustomEditorId == vscode.markdown.preview.editor",
 						"group": "navigation",
 						"order": 1
 					}

package.json

@@ -14062,6 +14062,16 @@
 					"when": "activeWebviewPanelId == gitlens.timeline && resourceScheme == webview-panel && config.gitlens.visualHistory.allowMultiple",
 					"group": "navigation@-97"
 				},
+				{
+					"command": "gitlens.ai.feedback.positive",
+					"when": "gitlens:markdown:feedback:available && activeCustomEditorId == vscode.markdown.preview.editor",
+					"group": "navigation@1"
+				},
+				{
+					"command": "gitlens.ai.feedback.negative",
+					"when": "gitlens:markdown:feedback:available && activeCustomEditorId == vscode.markdown.preview.editor",
+					"group": "navigation@2"
+				},
 				{
 					"command": "gitlens.clearFileAnnotations",
 					"when": "resource in gitlens:tabs:blameable && (gitlens:window:annotated == computed || (resource in gitlens:tabs:annotated && resource not in gitlens:tabs:annotated:computing)) && config.gitlens.menus.editorGroup.blame",
@@ -14136,16 +14146,6 @@
 					"when": "resourceScheme == gitlens-markdown && activeCustomEditorId == vscode.markdown.preview.editor",
 					"group": "navigation@0"
 				},
-				{
-					"command": "gitlens.ai.feedback.positive",
-					"when": "resourceScheme == gitlens-markdown && config.gitlens.telemetry.enabled && activeCustomEditorId == vscode.markdown.preview.editor",
-					"group": "navigation@1"
-				},
-				{
-					"command": "gitlens.ai.feedback.negative",
-					"when": "resourceScheme == gitlens-markdown && config.gitlens.telemetry.enabled && activeCustomEditorId == vscode.markdown.preview.editor",
-					"group": "navigation@2"
-				},
 				{
 					"command": "gitlens.openPatch",
 					"when": "false && editorLangId == diff"

src/commands/generateRebase.ts

@@ -547,8 +547,8 @@ function generateRebaseMarkdown(
 		},
 	};
 
-	// Add feedback context and commands to toolbar if telemetry is enabled
-	if (feedbackContext && telemetryEnabled) {
+	// Always store feedback context if available, but only show UI when telemetry is enabled
+	if (feedbackContext) {
 		metadata.feedbackContext = feedbackContext as unknown as Record<string, unknown>;
 	}
 

src/constants.context.ts

@@ -61,6 +61,7 @@ export type ContextKeys = {
 	'gitlens:vsls': boolean | 'host' | 'guest';
 	'gitlens:window:annotated': AnnotationStatus;
 	'gitlens:walkthroughSupported': boolean;
+	'gitlens:markdown:feedback:available': boolean;
 } & Record<`gitlens:action:${string}`, number> &
 	Record<`gitlens:feature:unsupported:${Features}`, boolean> &
 	Record<`gitlens:key:${Keys}`, boolean> &

src/container.ts

@@ -63,6 +63,7 @@ import { isWalkthroughSupported, WalkthroughStateProvider } from './telemetry/wa
 import { GitTerminalLinkProvider } from './terminal/linkProvider';
 import { GitDocumentTracker } from './trackers/documentTracker';
 import { LineTracker } from './trackers/lineTracker';
+import { MarkdownFeedbackTracker } from './trackers/markdownFeedbackTracker';
 import { DeepLinkService } from './uris/deepLinks/deepLinkService';
 import { UriService } from './uris/uriService';
 import { ViewFileDecorationProvider } from './views/viewDecorationProvider';
@@ -218,6 +219,7 @@ export class Container {
 		this._disposables.push((this._actionRunners = new ActionRunners(this)));
 		this._disposables.push((this._documentTracker = new GitDocumentTracker(this)));
 		this._disposables.push((this._lineTracker = new LineTracker(this, this._documentTracker)));
+		this._disposables.push(new MarkdownFeedbackTracker(this));
 		this._disposables.push((this._keyboard = new Keyboard()));
 		this._disposables.push((this._vsls = new VslsController(this)));
 		this._disposables.push((this._eventBus = new EventBus()));

src/trackers/markdownFeedbackTracker.ts

@@ -0,0 +1,122 @@
+import type { Disposable, TextDocument, TextEditor } from 'vscode';
+import { window, workspace } from 'vscode';
+import { Schemes } from '../constants';
+import type { Container } from '../container';
+import type { MarkdownContentMetadata } from '../documents/markdown';
+import { decodeGitLensRevisionUriAuthority } from '../git/gitUri.authority';
+import { setContext } from '../system/-webview/context';
+import { debug } from '../system/decorators/log';
+
+/**
+ * Tracks when a GitLens markdown document with feedback context is active
+ * and sets the appropriate context variable for toolbar button visibility
+ */
+export class MarkdownFeedbackTracker implements Disposable {
+	private readonly _disposables: Disposable[] = [];
+	private _currentHasFeedback = false;
+
+	constructor(private readonly container: Container) {
+		// Listen for text editor changes (for when editing markdown source)
+		this._disposables.push(window.onDidChangeActiveTextEditor(this.onActiveEditorChanged, this));
+
+		// Listen for document opens (for when markdown documents are opened)
+		this._disposables.push(workspace.onDidOpenTextDocument(this.onDocumentOpened, this));
+
+		// Listen for visible text editors changes (for when preview becomes active)
+		this._disposables.push(window.onDidChangeVisibleTextEditors(this.onVisibleEditorsChanged, this));
+
+		// Check initial state
+		this.checkCurrentState();
+	}
+
+	dispose(): void {
+		this._disposables.forEach(d => {
+			d.dispose();
+		});
+		// Clear context on disposal
+		void setContext('gitlens:markdown:feedback:available', false);
+	}
+
+	@debug()
+	private onActiveEditorChanged(editor: TextEditor | undefined): void {
+		console.log('MarkdownFeedbackTracker: Active editor changed', {
+			hasEditor: Boolean(editor),
+			scheme: editor?.document.uri.scheme,
+		});
+		this.checkCurrentState();
+	}
+
+	@debug()
+	private onDocumentOpened(document: TextDocument): void {
+		console.log('MarkdownFeedbackTracker: Document opened', {
+			scheme: document.uri.scheme,
+			authority: document.uri.authority,
+		});
+		if (document.uri.scheme === Schemes.GitLensMarkdown) {
+			this.checkCurrentState();
+		}
+	}
+
+	@debug()
+	private onVisibleEditorsChanged(editors: readonly TextEditor[]): void {
+		console.log('MarkdownFeedbackTracker: Visible editors changed', {
+			count: editors.length,
+			schemes: editors.map(e => e.document.uri.scheme),
+		});
+		this.checkCurrentState();
+	}
+
+	private checkCurrentState(): void {
+		// Check all open documents for GitLens markdown with feedback context
+		const hasFeedback = this.checkForFeedbackDocuments();
+
+		console.log('MarkdownFeedbackTracker: Checking current state', {
+			hasFeedback: hasFeedback,
+			telemetryEnabled: this.container.telemetry.enabled,
+		});
+
+		if (hasFeedback !== this._currentHasFeedback) {
+			this._currentHasFeedback = hasFeedback;
+			console.log('MarkdownFeedbackTracker: Setting context to', hasFeedback);
+			void setContext('gitlens:markdown:feedback:available', hasFeedback);
+		}
+	}
+
+	private checkForFeedbackDocuments(): boolean {
+		// Check all open documents for GitLens markdown with feedback context
+		for (const document of workspace.textDocuments) {
+			if (this.documentHasFeedback(document)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private documentHasFeedback(document: TextDocument): boolean {
+		const uri = document.uri;
+		if (uri.scheme !== Schemes.GitLensMarkdown) return false;
+
+		const authority = uri.authority;
+		if (!authority) return false;
+
+		try {
+			const metadata = decodeGitLensRevisionUriAuthority<MarkdownContentMetadata>(authority);
+
+			// Check if document has feedback context AND telemetry is enabled
+			const hasFeedbackContext = Boolean(metadata.feedbackContext);
+			const telemetryEnabled = this.container.telemetry.enabled;
+
+			console.log('MarkdownFeedbackTracker: Checking document feedback context', {
+				uri: uri.toString(),
+				hasFeedbackContext: hasFeedbackContext,
+				telemetryEnabled: telemetryEnabled,
+				metadata: metadata.feedbackContext ? 'present' : 'missing',
+			});
+
+			return hasFeedbackContext && telemetryEnabled;
+		} catch (error) {
+			console.log('MarkdownFeedbackTracker: Error decoding metadata', error);
+			return false;
+		}
+	}
+}