@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatStatus/chatStatusEntry.js

@@ -17,13 +17,24 @@ import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/wor
 import { ChatStatusDashboard } from './chatStatusDashboard.js';
 import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
 import { disposableWindowInterval } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
-import { isNewUser, isCompletionsEnabled } from './chatStatus.js';
+import { isNewUser } from './chatStatus.js';
 import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
+import { isCompletionsEnabled } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/completionsEnablement';
 
 registerCss(chatStatus);
 let ChatStatusBarEntry = class ChatStatusBarEntry extends Disposable {
-    static { this.ID = 'workbench.contrib.chatStatusBarEntry'; }
-    constructor(chatEntitlementService, instantiationService, statusbarService, editorService, configurationService, completionsService, chatSessionsService) {
+    static {
+        this.ID = "workbench.contrib.chatStatusBarEntry";
+    }
+    constructor(
+        chatEntitlementService,
+        instantiationService,
+        statusbarService,
+        editorService,
+        configurationService,
+        completionsService,
+        chatSessionsService
+    ) {
         super();
         this.chatEntitlementService = chatEntitlementService;
         this.instantiationService = instantiationService;
@@ -44,12 +55,16 @@ let ChatStatusBarEntry = class ChatStatusBarEntry extends Disposable {
             const props = this.getEntryProps();
             if (this.entry) {
                 this.entry.update(props);
+            } else {
+                this.entry = this.statusbarService.addEntry(props, "chat.statusBarEntry", StatusbarAlignment.RIGHT, {
+                    location: {
+                        id: "status.editor.mode",
+                        priority: 100.1
+                    },
+                    alignment: StatusbarAlignment.RIGHT
+                });
             }
-            else {
-                this.entry = this.statusbarService.addEntry(props, 'chat.statusBarEntry', StatusbarAlignment.RIGHT, { location: { id: 'status.editor.mode', priority: 100.1 }, alignment: StatusbarAlignment.RIGHT });
-            }
-        }
-        else {
+        } else {
             this.entry?.dispose();
             this.entry = undefined;
         }
@@ -66,7 +81,9 @@ let ChatStatusBarEntry = class ChatStatusBarEntry extends Disposable {
                 this.update();
             }
         }));
-        this._register(this.editorService.onDidActiveEditorChange(() => this.onDidActiveEditorChange()));
+        this._register(
+            this.editorService.onDidActiveEditorChange(() => this.onDidActiveEditorChange())
+        );
         this._register(this.configurationService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration(product.defaultChatAgent.completionsEnablementSetting)) {
                 this.update();
@@ -84,77 +101,70 @@ let ChatStatusBarEntry = class ChatStatusBarEntry extends Disposable {
         }
     }
     getEntryProps() {
-        let text = '$(copilot)';
-        let ariaLabel = ( localize(5437, "Copilot status"));
+        let text = "$(copilot)";
+        let ariaLabel = ( localize(5630, "Copilot status"));
         let kind;
         if (isNewUser(this.chatEntitlementService)) {
             const entitlement = this.chatEntitlementService.entitlement;
-            if (this.chatEntitlementService.sentiment.later ||
-                entitlement === ChatEntitlement.Available ||
-                isProUser(entitlement) ||
-                entitlement === ChatEntitlement.Free
-            ) {
-                const finishSetup = ( localize(5438, "Finish Setup"));
+            if (
+            this.chatEntitlementService.sentiment.later || entitlement === ChatEntitlement.Available || isProUser(entitlement) || entitlement === ChatEntitlement.Free) {
+                const finishSetup = ( localize(5631, "Finish Setup"));
                 text = `$(copilot) ${finishSetup}`;
                 ariaLabel = finishSetup;
-                kind = 'prominent';
+                kind = "prominent";
             }
-        }
-        else {
+        } else {
             const chatQuotaExceeded = this.chatEntitlementService.quotas.chat?.percentRemaining === 0;
             const completionsQuotaExceeded = this.chatEntitlementService.quotas.completions?.percentRemaining === 0;
             if (this.chatEntitlementService.sentiment.disabled || this.chatEntitlementService.sentiment.untrusted) {
-                text = '$(copilot-unavailable)';
-                ariaLabel = ( localize(5439, "Copilot disabled"));
+                text = "$(copilot-unavailable)";
+                ariaLabel = ( localize(5632, "Copilot disabled"));
             }
             else if (this.runningSessionsCount > 0) {
-                text = '$(copilot-in-progress)';
+                text = "$(copilot-in-progress)";
                 if (this.runningSessionsCount > 1) {
-                    ariaLabel = ( localize(5440, "{0} agent sessions in progress", this.runningSessionsCount));
-                }
-                else {
-                    ariaLabel = ( localize(5441, "1 agent session in progress"));
+                    ariaLabel = ( localize(5633, "{0} agent sessions in progress", this.runningSessionsCount));
+                } else {
+                    ariaLabel = ( localize(5634, "1 agent session in progress"));
                 }
             }
             else if (this.chatEntitlementService.entitlement === ChatEntitlement.Unknown) {
-                const signedOutWarning = ( localize(5442, "Signed out"));
-                text = `${this.chatEntitlementService.anonymous ? '$(copilot)' : '$(copilot-not-connected)'} ${signedOutWarning}`;
+                const signedOutWarning = ( localize(5635, "Signed out"));
+                text = `${this.chatEntitlementService.anonymous ? "$(copilot)" : "$(copilot-not-connected)"} ${signedOutWarning}`;
                 ariaLabel = signedOutWarning;
-                kind = 'prominent';
+                kind = "prominent";
             }
             else if (this.chatEntitlementService.entitlement === ChatEntitlement.Free && (chatQuotaExceeded || completionsQuotaExceeded)) {
                 let quotaWarning;
                 if (chatQuotaExceeded && !completionsQuotaExceeded) {
-                    quotaWarning = ( localize(5443, "Chat quota reached"));
-                }
-                else if (completionsQuotaExceeded && !chatQuotaExceeded) {
-                    quotaWarning = ( localize(5444, "Inline suggestions quota reached"));
-                }
-                else {
-                    quotaWarning = ( localize(5445, "Quota reached"));
+                    quotaWarning = ( localize(5636, "Chat quota reached"));
+                } else if (completionsQuotaExceeded && !chatQuotaExceeded) {
+                    quotaWarning = ( localize(5637, "Inline suggestions quota reached"));
+                } else {
+                    quotaWarning = ( localize(5638, "Quota reached"));
                 }
                 text = `$(copilot-warning) ${quotaWarning}`;
                 ariaLabel = quotaWarning;
-                kind = 'prominent';
+                kind = "prominent";
             }
             else if (this.editorService.activeTextEditorLanguageId && !isCompletionsEnabled(this.configurationService, this.editorService.activeTextEditorLanguageId)) {
-                text = '$(copilot-unavailable)';
-                ariaLabel = ( localize(5446, "Inline suggestions disabled"));
+                text = "$(copilot-unavailable)";
+                ariaLabel = ( localize(5639, "Inline suggestions disabled"));
             }
             else if (this.completionsService.isSnoozing()) {
-                text = '$(copilot-snooze)';
-                ariaLabel = ( localize(5447, "Inline suggestions snoozed"));
+                text = "$(copilot-snooze)";
+                ariaLabel = ( localize(5640, "Inline suggestions snoozed"));
             }
         }
         const baseResult = {
-            name: ( localize(5448, "Copilot Status")),
+            name: ( localize(5641, "Copilot Status")),
             text,
             ariaLabel,
             command: ShowTooltipCommand,
             showInAllWindows: true,
             kind,
             tooltip: {
-                element: (token) => {
+                element: token => {
                     const store = ( new DisposableStore());
                     store.add(token.onCancellationRequested(() => {
                         store.dispose();
@@ -177,14 +187,6 @@ let ChatStatusBarEntry = class ChatStatusBarEntry extends Disposable {
         this.entry = undefined;
     }
 };
-ChatStatusBarEntry = ( __decorate([
-    ( __param(0, IChatEntitlementService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IStatusbarService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IInlineCompletionsService)),
-    ( __param(6, IChatSessionsService))
-], ChatStatusBarEntry));
+ChatStatusBarEntry = ( __decorate([( __param(0, IChatEntitlementService)), ( __param(1, IInstantiationService)), ( __param(2, IStatusbarService)), ( __param(3, IEditorService)), ( __param(4, IConfigurationService)), ( __param(5, IInlineCompletionsService)), ( __param(6, IChatSessionsService))], ChatStatusBarEntry));
 
 export { ChatStatusBarEntry };

package/vscode/src/vs/workbench/contrib/chat/browser/chatStatus/chatStatusItemService.js

@@ -13,7 +13,9 @@ class ChatStatusItemService {
         const isUpdate = ( this._entries.has(entry.id));
         this._entries.set(entry.id, entry);
         if (isUpdate) {
-            this._onDidChange.fire({ entry });
+            this._onDidChange.fire({
+                entry
+            });
         }
     }
     deleteEntry(id) {

package/vscode/src/vs/workbench/contrib/chat/browser/chatTipService.d.ts

@@ -0,0 +1,37 @@
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { MarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IChatTipService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatTipService.service";
+export interface IChatTip {
+    readonly id: string;
+    readonly content: MarkdownString;
+}
+export declare class ChatTipService implements IChatTipService {
+    private readonly _productService;
+    private readonly _configurationService;
+    readonly _serviceBrand: undefined;
+    /**
+     * Timestamp when this service was instantiated.
+     * Used to only show tips for requests created after this time.
+     */
+    private readonly _createdAt;
+    /**
+     * Whether a tip has already been shown in this window session.
+     * Only one tip is shown per session.
+     */
+    private _hasShownTip;
+    /**
+     * The request ID that was assigned a tip (for stable rerenders).
+     */
+    private _tipRequestId;
+    /**
+     * The tip that was shown (for stable rerenders).
+     */
+    private _shownTip;
+    constructor(_productService: IProductService, _configurationService: IConfigurationService);
+    getNextTip(requestId: string, requestTimestamp: number, contextKeyService: IContextKeyService): IChatTip | undefined;
+    private _isEligible;
+    private _isCopilotEnabled;
+    private _createTip;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/chatTipService.js

@@ -0,0 +1,109 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+
+const TIP_CATALOG = [{
+    id: "tip.agentMode",
+    message: ( localize(
+        5642,
+        "Tip: Try [Agent mode](command:workbench.action.chat.openEditSession) for multi-file edits and running commands."
+    )),
+    when: ( ChatContextKeys.chatModeKind.notEqualsTo(ChatModeKind.Agent)),
+    enabledCommands: ["workbench.action.chat.openEditSession"]
+}, {
+    id: "tip.planMode",
+    message: ( localize(
+        5643,
+        "Tip: Try [Plan mode](command:workbench.action.chat.openPlan) to let the agent perform deep analysis and planning before implementing changes."
+    )),
+    when: ( ChatContextKeys.chatModeName.notEqualsTo("Plan")),
+    enabledCommands: ["workbench.action.chat.openPlan"]
+}, {
+    id: "tip.attachFiles",
+    message: ( localize(5644, "Tip: Attach files or folders with # to give Copilot more context."))
+}, {
+    id: "tip.codeActions",
+    message: ( localize(
+        5645,
+        "Tip: Select code and right-click for Copilot actions in the context menu."
+    ))
+}, {
+    id: "tip.undoChanges",
+    message: ( localize(
+        5646,
+        "Tip: You can undo Copilot's changes to any point by clicking Restore Checkpoint."
+    )),
+    when: ( ContextKeyExpr.or(( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)), ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Edit))))
+}, {
+    id: "tip.customInstructions",
+    message: ( localize(
+        5647,
+        "Tip: [Generate workspace instructions](command:workbench.action.chat.generateInstructions) so Copilot always has the context it needs when starting a task."
+    )),
+    enabledCommands: ["workbench.action.chat.generateInstructions"]
+}];
+let ChatTipService = class ChatTipService {
+    constructor(_productService, _configurationService) {
+        this._productService = _productService;
+        this._configurationService = _configurationService;
+        this._createdAt = Date.now();
+        this._hasShownTip = false;
+    }
+    getNextTip(requestId, requestTimestamp, contextKeyService) {
+        if (!this._configurationService.getValue("chat.tips.enabled")) {
+            return undefined;
+        }
+        if (!this._isCopilotEnabled()) {
+            return undefined;
+        }
+        if (this._tipRequestId === requestId && this._shownTip) {
+            return this._createTip(this._shownTip);
+        }
+        if (this._hasShownTip) {
+            return undefined;
+        }
+        if (requestTimestamp < this._createdAt) {
+            return undefined;
+        }
+        const eligibleTips = TIP_CATALOG.filter(tip => this._isEligible(tip, contextKeyService));
+        if (eligibleTips.length === 0) {
+            return undefined;
+        }
+        const randomIndex = Math.floor(Math.random() * eligibleTips.length);
+        const selectedTip = eligibleTips[randomIndex];
+        this._hasShownTip = true;
+        this._tipRequestId = requestId;
+        this._shownTip = selectedTip;
+        return this._createTip(selectedTip);
+    }
+    _isEligible(tip, contextKeyService) {
+        if (!tip.when) {
+            return true;
+        }
+        return contextKeyService.contextMatchesRules(tip.when);
+    }
+    _isCopilotEnabled() {
+        const defaultChatAgent = this._productService.defaultChatAgent;
+        return !!defaultChatAgent?.chatExtensionId;
+    }
+    _createTip(tipDef) {
+        const markdown = ( new MarkdownString(tipDef.message, {
+            isTrusted: tipDef.enabledCommands ? {
+                enabledCommands: tipDef.enabledCommands
+            } : false
+        }));
+        return {
+            id: tipDef.id,
+            content: markdown
+        };
+    }
+};
+ChatTipService = ( __decorate([( __param(0, IProductService)), ( __param(1, IConfigurationService))], ChatTipService));
+
+export { ChatTipService };

package/vscode/src/vs/workbench/contrib/chat/browser/chatWindowNotifier.js

@@ -14,7 +14,9 @@ import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workb
 import { autorunIterableDelta, autorunDelta } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 let ChatWindowNotifier = class ChatWindowNotifier extends Disposable {
-    static { this.ID = 'workbench.contrib.chatWindowNotifier'; }
+    static {
+        this.ID = "workbench.contrib.chatWindowNotifier";
+    }
     constructor(_chatService, _chatWidgetService, _hostService, _configurationService) {
         super();
         this._chatService = _chatService;
@@ -23,29 +25,40 @@ let ChatWindowNotifier = class ChatWindowNotifier extends Disposable {
         this._configurationService = _configurationService;
         this._activeNotifications = this._register(( new DisposableResourceMap()));
         const modelTrackers = this._register(( new DisposableResourceMap()));
-        this._register(autorunIterableDelta(reader => this._chatService.chatModels.read(reader), ({ addedValues, removedValues }) => {
-            for (const model of addedValues) {
-                modelTrackers.set(model.sessionResource, this._trackModel(model));
-            }
-            for (const model of removedValues) {
-                modelTrackers.deleteAndDispose(model.sessionResource);
-            }
-        }));
+        this._register(
+            autorunIterableDelta(reader => this._chatService.chatModels.read(reader), (
+                {
+                    addedValues,
+                    removedValues
+                }
+            ) => {
+                for (const model of addedValues) {
+                    modelTrackers.set(model.sessionResource, this._trackModel(model));
+                }
+                for (const model of removedValues) {
+                    modelTrackers.deleteAndDispose(model.sessionResource);
+                }
+            })
+        );
     }
     _trackModel(model) {
-        return autorunDelta(model.requestNeedsInput, ({ lastValue, newValue }) => {
+        return autorunDelta(model.requestNeedsInput, (
+            {
+                lastValue,
+                newValue
+            }
+        ) => {
             const currentNeedsInput = !!newValue;
             const previousNeedsInput = !!lastValue;
             if (!previousNeedsInput && currentNeedsInput && newValue) {
                 this._notifyIfNeeded(model.sessionResource, newValue);
-            }
-            else if (previousNeedsInput && !currentNeedsInput) {
+            } else if (previousNeedsInput && !currentNeedsInput) {
                 this._clearNotification(model.sessionResource);
             }
         });
     }
     async _notifyIfNeeded(sessionResource, info) {
-        if (!this._configurationService.getValue('chat.notifyWindowOnConfirmation')) {
+        if (!this._configurationService.getValue("chat.notifyWindowOnConfirmation")) {
             return;
         }
         const widget = this._chatWidgetService.getWidgetBySessionResource(sessionResource);
@@ -54,17 +67,21 @@ let ChatWindowNotifier = class ChatWindowNotifier extends Disposable {
             return;
         }
         this._clearNotification(sessionResource);
-        await this._hostService.focus(targetWindow, { mode: FocusMode.Notify });
-        const notificationTitle = info.title ? ( localize(5449, "Chat: {0}", info.title)) : ( localize(5450, "Untitled Chat"));
+        await this._hostService.focus(targetWindow, {
+            mode: FocusMode.Notify
+        });
+        const notificationTitle = info.title ? ( localize(5648, "Chat: {0}", info.title)) : ( localize(5649, "Untitled Chat"));
         const notification = await triggerNotification(notificationTitle, {
-            detail: info.detail ?? ( localize(5451, "Approval needed to continue."))
+            detail: info.detail ?? ( localize(5650, "Approval needed to continue."))
         });
         if (notification) {
             const disposables = ( new DisposableStore());
             this._activeNotifications.set(sessionResource, disposables);
             disposables.add(notification);
             disposables.add(Event.once(notification.onClick)(async () => {
-                await this._hostService.focus(targetWindow, { mode: FocusMode.Force });
+                await this._hostService.focus(targetWindow, {
+                    mode: FocusMode.Force
+                });
                 const widget = await this._chatWidgetService.openSession(sessionResource);
                 widget?.focusInput();
                 this._clearNotification(sessionResource);
@@ -80,11 +97,6 @@ let ChatWindowNotifier = class ChatWindowNotifier extends Disposable {
         this._activeNotifications.deleteAndDispose(sessionResource);
     }
 };
-ChatWindowNotifier = ( __decorate([
-    ( __param(0, IChatService)),
-    ( __param(1, IChatWidgetService)),
-    ( __param(2, IHostService)),
-    ( __param(3, IConfigurationService))
-], ChatWindowNotifier));
+ChatWindowNotifier = ( __decorate([( __param(0, IChatService)), ( __param(1, IChatWidgetService)), ( __param(2, IHostService)), ( __param(3, IConfigurationService))], ChatWindowNotifier));
 
 export { ChatWindowNotifier };

package/vscode/src/vs/workbench/contrib/chat/browser/contextContrib/chatContextService.d.ts

@@ -1,7 +1,7 @@
 import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
 import { LanguageSelector } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languageSelector";
 import { IChatContextPickService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatContextPickService.service";
-import { IChatContextItem, IChatContextProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/contextContrib/chatContext";
+import { IChatContextItem, IChatExplicitContextProvider, IChatResourceContextProvider, IChatWorkspaceContextProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/contextContrib/chatContext";
 import { IChatRequestWorkspaceVariableEntry, StringChatContextValue } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries";
 import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
@@ -14,18 +14,23 @@ export declare class ChatContextService extends Disposable {
     private readonly _workspaceContext;
     private readonly _registeredPickers;
     private _lastResourceContext;
+    private _executeCommandCallback;
     constructor(_contextPickService: IChatContextPickService, _extensionService: IExtensionService);
+    setExecuteCommandCallback(callback: (itemHandle: number) => Promise<void>): void;
+    executeChatContextItemCommand(handle: number): Promise<void>;
     setChatContextProvider(id: string, picker: {
         title: string;
         icon: ThemeIcon;
     }): void;
     private _registerWithPickService;
-    registerChatContextProvider(id: string, selector: LanguageSelector | undefined, provider: IChatContextProvider): void;
+    registerChatWorkspaceContextProvider(id: string, provider: IChatWorkspaceContextProvider): void;
+    registerChatExplicitContextProvider(id: string, provider: IChatExplicitContextProvider): void;
+    registerChatResourceContextProvider(id: string, selector: LanguageSelector, provider: IChatResourceContextProvider): void;
     unregisterChatContextProvider(id: string): void;
     updateWorkspaceContextItems(id: string, items: IChatContextItem[]): void;
     getWorkspaceContextItems(): IChatRequestWorkspaceVariableEntry[];
-    contextForResource(uri: URI): Promise<StringChatContextValue | undefined>;
+    contextForResource(uri: URI, language?: string): Promise<StringChatContextValue | undefined>;
     private _contextForResource;
-    resolveChatContext(context: StringChatContextValue): Promise<StringChatContextValue>;
+    resolveChatContext(context: StringChatContextValue, language?: string): Promise<StringChatContextValue>;
     private _asPicker;
 }