@codingame/monaco-vscode-chat-service-override 21.6.0 → 22.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions/view/chatSessionsView.js

@@ -0,0 +1,268 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { ViewPaneContainer } from '@codingame/monaco-vscode-a8d3bd74-e63e-5327-96e8-4f931661e329-common/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+import { Extensions, ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
+import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { ChatConfiguration, VIEWLET_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ACTION_ID_OPEN_CHAT } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ChatSessionTracker } from '../chatSessionTracker.js';
+import { LocalChatSessionsProvider } from '../localChatSessionsProvider.js';
+import { SessionsViewPane } from './sessionsViewPane.js';
+
+let ChatSessionsView = class ChatSessionsView extends Disposable {
+    static { this.ID = 'workbench.contrib.chatSessions'; }
+    constructor(configurationService, instantiationService, chatSessionsService, chatEntitlementService) {
+        super();
+        this.configurationService = configurationService;
+        this.instantiationService = instantiationService;
+        this.chatSessionsService = chatSessionsService;
+        this.chatEntitlementService = chatEntitlementService;
+        this.isViewContainerRegistered = false;
+        this.sessionTracker = this._register(this.instantiationService.createInstance(ChatSessionTracker));
+        this.setupEditorTracking();
+        this.localProvider = this._register(this.instantiationService.createInstance(LocalChatSessionsProvider));
+        this._register(this.chatSessionsService.registerChatSessionItemProvider(this.localProvider));
+        this.updateViewContainerRegistration();
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.AgentSessionsViewLocation)) {
+                this.updateViewContainerRegistration();
+            }
+        }));
+        this._register(this.chatEntitlementService.onDidChangeSentiment(e => {
+            this.updateViewContainerRegistration();
+        }));
+    }
+    setupEditorTracking() {
+        this._register(this.sessionTracker.onDidChangeEditors(e => {
+            this.chatSessionsService.notifySessionItemsChanged(e.sessionType);
+        }));
+    }
+    updateViewContainerRegistration() {
+        const location = this.configurationService.getValue(ChatConfiguration.AgentSessionsViewLocation);
+        const sentiment = this.chatEntitlementService.sentiment;
+        if (sentiment.disabled || sentiment.hidden || (location !== 'view' && this.isViewContainerRegistered)) {
+            this.deregisterViewContainer();
+        }
+        else if (location === 'view' && !this.isViewContainerRegistered) {
+            this.registerViewContainer();
+        }
+    }
+    registerViewContainer() {
+        if (this.isViewContainerRegistered) {
+            return;
+        }
+        this.viewContainer = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+            id: VIEWLET_ID,
+            title: ( localize2(5238, "Chat Sessions")),
+            ctorDescriptor: ( new SyncDescriptor(ChatSessionsViewPaneContainer, [this.sessionTracker])),
+            hideIfEmpty: false,
+            icon: registerIcon('chat-sessions-icon', Codicon.commentDiscussionSparkle, 'Icon for Chat Sessions View'),
+            order: 6
+        }, ViewContainerLocation.Sidebar);
+        this.isViewContainerRegistered = true;
+    }
+    deregisterViewContainer() {
+        if (this.viewContainer) {
+            const allViews = ( Registry.as(Extensions.ViewsRegistry)).getViews(this.viewContainer);
+            if (allViews.length > 0) {
+                ( Registry.as(Extensions.ViewsRegistry)).deregisterViews(allViews, this.viewContainer);
+            }
+            ( Registry.as(Extensions.ViewContainersRegistry)).deregisterViewContainer(this.viewContainer);
+            this.viewContainer = undefined;
+            this.isViewContainerRegistered = false;
+        }
+    }
+};
+ChatSessionsView = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IChatSessionsService)),
+    ( __param(3, IChatEntitlementService))
+], ChatSessionsView));
+let ChatSessionsViewPaneContainer = class ChatSessionsViewPaneContainer extends ViewPaneContainer {
+    constructor(sessionTracker, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService, logService, productService, chatSessionsService) {
+        super(VIEWLET_ID, {
+            mergeViewWithContainerWhenSingleView: false,
+        }, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService, logService);
+        this.sessionTracker = sessionTracker;
+        this.productService = productService;
+        this.chatSessionsService = chatSessionsService;
+        this.registeredViewDescriptors = ( new Map());
+        this.updateViewRegistration();
+        this._register(this.chatSessionsService.onDidChangeItemsProviders(() => {
+            this.updateViewRegistration();
+        }));
+        this._register(this.chatSessionsService.onDidChangeSessionItems((chatSessionType) => {
+            this.refreshProviderTree(chatSessionType);
+        }));
+        this._register(this.chatSessionsService.onDidChangeAvailability(() => {
+            this.updateViewRegistration();
+        }));
+    }
+    getTitle() {
+        const title = ( localize(5239, "Chat Sessions"));
+        return title;
+    }
+    getAllChatSessionItemProviders() {
+        return Array.from(this.chatSessionsService.getAllChatSessionItemProviders());
+    }
+    refreshProviderTree(chatSessionType) {
+        const providers = this.getAllChatSessionItemProviders();
+        const targetProvider = providers.find(provider => provider.chatSessionType === chatSessionType);
+        if (targetProvider) {
+            const viewId = `${VIEWLET_ID}.${chatSessionType}`;
+            const view = this.getView(viewId);
+            if (view) {
+                view.refreshTree();
+            }
+        }
+    }
+    async updateViewRegistration() {
+        const contributions = this.chatSessionsService.getAllChatSessionContributions();
+        await Promise.all(( contributions.map(contrib => this.chatSessionsService.canResolveItemProvider(contrib.type))));
+        const currentProviders = this.getAllChatSessionItemProviders();
+        const currentProviderIds = ( new Set(( currentProviders.map(p => p.chatSessionType))));
+        const viewsToUnregister = [];
+        for (const [providerId, viewDescriptor] of this.registeredViewDescriptors.entries()) {
+            if (!( currentProviderIds.has(providerId))) {
+                viewsToUnregister.push(viewDescriptor);
+                this.registeredViewDescriptors.delete(providerId);
+            }
+        }
+        if (viewsToUnregister.length > 0) {
+            const container = ( Registry.as(Extensions.ViewContainersRegistry)).get(VIEWLET_ID);
+            if (container) {
+                ( Registry.as(Extensions.ViewsRegistry)).deregisterViews(viewsToUnregister, container);
+            }
+        }
+        this.registerViews(contributions);
+    }
+    async registerViews(extensionPointContributions) {
+        const container = ( Registry.as(Extensions.ViewContainersRegistry)).get(VIEWLET_ID);
+        const providers = this.getAllChatSessionItemProviders();
+        if (container && providers.length > 0) {
+            const viewDescriptorsToRegister = [];
+            const localProvider = providers.find(p => p.chatSessionType === 'local');
+            const historyProvider = providers.find(p => p.chatSessionType === 'history');
+            const otherProviders = providers.filter(p => p.chatSessionType !== 'local' && p.chatSessionType !== 'history');
+            const providersWithDisplayNames = ( otherProviders.map(provider => {
+                const extContribution = extensionPointContributions.find(c => c.type === provider.chatSessionType);
+                if (!extContribution) {
+                    this.logService.warn(`No extension contribution found for chat session type: ${provider.chatSessionType}`);
+                    return null;
+                }
+                return {
+                    provider,
+                    displayName: extContribution.displayName
+                };
+            })).filter(item => item !== null);
+            providersWithDisplayNames.sort((a, b) => a.displayName.localeCompare(b.displayName));
+            const orderedProviders = [
+                ...(localProvider ? [{ provider: localProvider, displayName: 'Local Chat Sessions', baseOrder: 0 }] : []),
+                ...(historyProvider ? [{ provider: historyProvider, displayName: 'History', baseOrder: 1, when: undefined }] : []),
+                ...( providersWithDisplayNames.map((item, index) => ({
+                    ...item,
+                    baseOrder: 2 + index,
+                    when: undefined,
+                })))
+            ];
+            orderedProviders.forEach(({ provider, displayName, baseOrder, when }) => {
+                if (!( this.registeredViewDescriptors.has(provider.chatSessionType))) {
+                    const viewDescriptor = {
+                        id: `${VIEWLET_ID}.${provider.chatSessionType}`,
+                        name: {
+                            value: displayName,
+                            original: displayName,
+                        },
+                        ctorDescriptor: ( new SyncDescriptor(SessionsViewPane, [provider, this.sessionTracker])),
+                        canToggleVisibility: true,
+                        canMoveView: true,
+                        order: baseOrder,
+                        when,
+                    };
+                    viewDescriptorsToRegister.push(viewDescriptor);
+                    this.registeredViewDescriptors.set(provider.chatSessionType, viewDescriptor);
+                    if (provider.chatSessionType === 'local') {
+                        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+                        this._register(viewsRegistry.registerViewWelcomeContent(viewDescriptor.id, {
+                            content: ( localize(
+                                5240,
+                                "No local chat sessions\n[Start a Chat](command:{0})",
+                                ACTION_ID_OPEN_CHAT
+                            )),
+                        }));
+                    }
+                }
+            });
+            const gettingStartedViewId = `${VIEWLET_ID}.gettingStarted`;
+            if (!( this.registeredViewDescriptors.has('gettingStarted'))
+                && this.productService.chatSessionRecommendations
+                && this.productService.chatSessionRecommendations.length) {
+                const gettingStartedDescriptor = {
+                    id: gettingStartedViewId,
+                    name: {
+                        value: ( localize(5241, "Getting Started")),
+                        original: 'Getting Started',
+                    },
+                    ctorDescriptor: ( new SyncDescriptor(SessionsViewPane, [null, this.sessionTracker])),
+                    canToggleVisibility: true,
+                    canMoveView: true,
+                    order: 1000,
+                    collapsed: !!otherProviders.length,
+                };
+                viewDescriptorsToRegister.push(gettingStartedDescriptor);
+                this.registeredViewDescriptors.set('gettingStarted', gettingStartedDescriptor);
+            }
+            if (viewDescriptorsToRegister.length > 0) {
+                ( Registry.as(Extensions.ViewsRegistry)).registerViews(viewDescriptorsToRegister, container);
+            }
+        }
+    }
+    dispose() {
+        if (this.registeredViewDescriptors.size > 0) {
+            const container = ( Registry.as(Extensions.ViewContainersRegistry)).get(VIEWLET_ID);
+            if (container) {
+                const allRegisteredViews = Array.from(( this.registeredViewDescriptors.values()));
+                ( Registry.as(Extensions.ViewsRegistry)).deregisterViews(allRegisteredViews, container);
+            }
+            this.registeredViewDescriptors.clear();
+        }
+        super.dispose();
+    }
+};
+ChatSessionsViewPaneContainer = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IWorkbenchLayoutService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, ITelemetryService)),
+    ( __param(6, IExtensionService)),
+    ( __param(7, IThemeService)),
+    ( __param(8, IStorageService)),
+    ( __param(9, IWorkspaceContextService)),
+    ( __param(10, IViewDescriptorService)),
+    ( __param(11, ILogService)),
+    ( __param(12, IProductService)),
+    ( __param(13, IChatSessionsService))
+], ChatSessionsViewPaneContainer));
+
+export { ChatSessionsView };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions/view/sessionsTreeRenderer.d.ts

@@ -0,0 +1,93 @@
+import { ActionBar } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar";
+import { IAsyncDataSource, ITreeNode, ITreeRenderer } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/tree/tree";
+import { FuzzyScore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/filters";
+import { Disposable, DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { IMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IContextViewService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IResourceLabel, ResourceLabels } from "@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common/vscode/vs/workbench/browser/labels";
+import { IconLabel } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabel";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { ChatSessionStatus, IChatSessionItem, IChatSessionItemProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { ChatSessionItemWithProvider } from "../common.js";
+import { IListRenderer, IListVirtualDelegate } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/list";
+import { ChatSessionTracker } from "../chatSessionTracker.js";
+interface ISessionTemplateData {
+    readonly container: HTMLElement;
+    readonly iconLabel: IconLabel;
+    readonly actionBar: ActionBar;
+    readonly elementDisposable: DisposableStore;
+    readonly timestamp: HTMLElement;
+    readonly descriptionRow: HTMLElement;
+    readonly descriptionLabel: HTMLElement;
+    readonly statisticsLabel: HTMLElement;
+    readonly customIcon: HTMLElement;
+}
+export interface IGettingStartedItem {
+    id: string;
+    label: string;
+    commandId: string;
+    icon?: ThemeIcon;
+    args?: any[];
+}
+export declare class GettingStartedDelegate implements IListVirtualDelegate<IGettingStartedItem> {
+    getHeight(): number;
+    getTemplateId(): string;
+}
+interface IGettingStartedTemplateData {
+    resourceLabel: IResourceLabel;
+}
+export declare class GettingStartedRenderer implements IListRenderer<IGettingStartedItem, IGettingStartedTemplateData> {
+    private readonly labels;
+    readonly templateId = "gettingStartedItem";
+    constructor(labels: ResourceLabels);
+    renderTemplate(container: HTMLElement): IGettingStartedTemplateData;
+    renderElement(element: IGettingStartedItem, index: number, templateData: IGettingStartedTemplateData): void;
+    disposeTemplate(templateData: IGettingStartedTemplateData): void;
+}
+export declare class SessionsRenderer extends Disposable implements ITreeRenderer<IChatSessionItem, FuzzyScore, ISessionTemplateData> {
+    private readonly contextViewService;
+    private readonly configurationService;
+    private readonly chatSessionsService;
+    private readonly menuService;
+    private readonly contextKeyService;
+    private readonly hoverService;
+    private readonly chatWidgetService;
+    private readonly chatService;
+    private readonly editorGroupsService;
+    static readonly TEMPLATE_ID = "session";
+    private markdownRenderer;
+    constructor(contextViewService: IContextViewService, configurationService: IConfigurationService, chatSessionsService: IChatSessionsService, menuService: IMenuService, contextKeyService: IContextKeyService, hoverService: IHoverService, instantiationService: IInstantiationService, chatWidgetService: IChatWidgetService, chatService: IChatService, editorGroupsService: IEditorGroupsService);
+    get templateId(): string;
+    renderTemplate(container: HTMLElement): ISessionTemplateData;
+    statusToIcon(status?: ChatSessionStatus): ThemeIcon;
+    renderElement(element: ITreeNode<IChatSessionItem, FuzzyScore>, index: number, templateData: ISessionTemplateData): void;
+    disposeElement(_element: ITreeNode<IChatSessionItem, FuzzyScore>, _index: number, templateData: ISessionTemplateData): void;
+    private renderInputBox;
+    disposeTemplate(templateData: ISessionTemplateData): void;
+}
+export declare class SessionsDataSource implements IAsyncDataSource<IChatSessionItemProvider, ChatSessionItemWithProvider> {
+    private readonly provider;
+    private readonly chatService;
+    private readonly sessionTracker;
+    constructor(provider: IChatSessionItemProvider, chatService: IChatService, sessionTracker: ChatSessionTracker);
+    hasChildren(element: IChatSessionItemProvider | ChatSessionItemWithProvider): boolean;
+    getChildren(element: IChatSessionItemProvider | ChatSessionItemWithProvider): Promise<ChatSessionItemWithProvider[]>;
+    private getHistoryItems;
+}
+export declare class SessionsDelegate implements IListVirtualDelegate<ChatSessionItemWithProvider> {
+    private readonly configurationService;
+    static readonly ITEM_HEIGHT = 22;
+    static readonly ITEM_HEIGHT_WITH_DESCRIPTION = 44;
+    constructor(configurationService: IConfigurationService);
+    getHeight(element: ChatSessionItemWithProvider): number;
+    getTemplateId(element: ChatSessionItemWithProvider): string;
+}
+export {};