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

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

@@ -0,0 +1,409 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { append, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { MarshalledId } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
+import { truncate } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { DropdownWithPrimaryActionViewItem } from '@codingame/monaco-vscode-09e9b2e8-42a8-5a68-864f-bfcdad0ca1df-common/vscode/vs/platform/actions/browser/dropdownWithPrimaryActionViewItem';
+import { getActionBarActions } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuItemAction, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.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 { IContextMenuService } 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 { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { WorkbenchAsyncDataTree, WorkbenchList } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { fillEditorsDragData } from '@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common/vscode/vs/workbench/browser/dnd';
+import { ResourceLabels } from '@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common/vscode/vs/workbench/browser/labels';
+import { ViewPane } from '@codingame/monaco-vscode-501b06ab-3f58-516b-8a1a-c29d375d3da4-common/vscode/vs/workbench/browser/parts/views/viewPane';
+import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatSessionUri } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatUri';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatViewId } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatEditorInput } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { ACTION_ID_OPEN_CHAT } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { NEW_CHAT_SESSION_ACTION_ID, findExistingChatEditorByUri, isLocalChatSessionItem, getSessionItemContextOverlay } from '../common.js';
+import { LocalChatSessionsProvider } from '../localChatSessionsProvider.js';
+import { SessionsDataSource, SessionsDelegate, SessionsRenderer, GettingStartedDelegate, GettingStartedRenderer } from './sessionsTreeRenderer.js';
+
+class SessionsIdentityProvider {
+    getId(element) {
+        return element.id;
+    }
+}
+class SessionsAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return localize(5244, 'Chat Sessions');
+    }
+    getAriaLabel(element) {
+        return element.label || element.id;
+    }
+}
+let SessionsViewPane = class SessionsViewPane extends ViewPane {
+    constructor(provider, sessionTracker, options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService, chatService, editorService, viewsService, logService, progressService, menuService, commandService, chatWidgetService, editorGroupsService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService);
+        this.provider = provider;
+        this.sessionTracker = sessionTracker;
+        this.chatService = chatService;
+        this.editorService = editorService;
+        this.viewsService = viewsService;
+        this.logService = logService;
+        this.progressService = progressService;
+        this.menuService = menuService;
+        this.commandService = commandService;
+        this.chatWidgetService = chatWidgetService;
+        this.editorGroupsService = editorGroupsService;
+        this._isEmpty = true;
+        if (provider instanceof LocalChatSessionsProvider) {
+            this._register(provider.onDidChange(() => {
+                if (this.tree && this.isBodyVisible()) {
+                    this.refreshTreeWithProgress();
+                }
+            }));
+        }
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.ShowAgentSessionsViewDescription)) {
+                if (this.tree && this.isBodyVisible()) {
+                    this.refreshTreeWithProgress();
+                }
+            }
+        }));
+    }
+    shouldShowWelcome() {
+        return this._isEmpty;
+    }
+    createActionViewItem(action, options) {
+        if (action.id.startsWith(NEW_CHAT_SESSION_ACTION_ID)) {
+            return this.getChatSessionDropdown(action, options);
+        }
+        return super.createActionViewItem(action, options);
+    }
+    getChatSessionDropdown(defaultAction, options) {
+        const primaryAction = this.instantiationService.createInstance(MenuItemAction, {
+            id: defaultAction.id,
+            title: defaultAction.label,
+            icon: Codicon.plus,
+        }, undefined, undefined, undefined, undefined);
+        const menu = this.menuService.createMenu(MenuId.ChatSessionsMenu, this.contextKeyService);
+        const actions = menu.getActions({ shouldForwardArgs: true });
+        const primaryActions = getActionBarActions(actions, 'submenu').primary.filter(action => {
+            if (action instanceof MenuItemAction && defaultAction instanceof MenuItemAction) {
+                if (!action.item.source?.id || !defaultAction.item.source?.id) {
+                    return false;
+                }
+                if (action.item.source.id === defaultAction.item.source.id) {
+                    return true;
+                }
+            }
+            return false;
+        });
+        if (!primaryActions || primaryActions.length === 0) {
+            return;
+        }
+        const dropdownAction = ( new Action('selectNewChatSessionOption', ( localize(5245, 'More...')), 'codicon-chevron-down', true));
+        const dropdownActions = [];
+        primaryActions.forEach(element => {
+            dropdownActions.push(element);
+        });
+        return this.instantiationService.createInstance(DropdownWithPrimaryActionViewItem, primaryAction, dropdownAction, dropdownActions, '', options);
+    }
+    refreshTree() {
+        if (this.tree && this.isBodyVisible()) {
+            this.refreshTreeWithProgress();
+        }
+    }
+    isEmpty() {
+        if (!this.tree?.hasNode(this.provider)) {
+            return true;
+        }
+        const providerNode = this.tree.getNode(this.provider);
+        const childCount = providerNode.children?.length || 0;
+        return childCount === 0;
+    }
+    updateEmptyState() {
+        try {
+            const newEmptyState = this.isEmpty();
+            if (newEmptyState !== this._isEmpty) {
+                this._isEmpty = newEmptyState;
+                this._onDidChangeViewWelcomeState.fire();
+            }
+        }
+        catch (error) {
+            this.logService.error('Error checking tree data for empty state:', error);
+        }
+    }
+    async refreshTreeWithProgress() {
+        if (!this.tree) {
+            return;
+        }
+        try {
+            await this.progressService.withProgress({
+                location: this.id,
+                title: ( localize(5246, 'Refreshing chat sessions...')),
+            }, async () => {
+                await this.tree.updateChildren(this.provider);
+            });
+            this.updateEmptyState();
+        }
+        catch (error) {
+            this.logService.error('Error refreshing chat sessions tree:', error);
+        }
+    }
+    async loadDataWithProgress() {
+        if (!this.tree) {
+            return;
+        }
+        try {
+            await this.progressService.withProgress({
+                location: this.id,
+                title: ( localize(5247, 'Loading chat sessions...')),
+            }, async () => {
+                await this.tree.setInput(this.provider);
+            });
+            this.updateEmptyState();
+        }
+        catch (error) {
+            this.logService.error('Error loading chat sessions data:', error);
+        }
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        container.classList.add('chat-sessions-view');
+        if (this.provider === null) {
+            this.renderGettingStartedList(container);
+            return;
+        }
+        this.treeContainer = append(container, $('.chat-sessions-tree-container'));
+        this.messageElement = append(container, $('.chat-sessions-message'));
+        this.messageElement.style.display = 'none';
+        const dataSource = ( new SessionsDataSource(this.provider, this.chatService, this.sessionTracker));
+        const delegate = ( new SessionsDelegate(this.configurationService));
+        const identityProvider = ( new SessionsIdentityProvider());
+        const accessibilityProvider = ( new SessionsAccessibilityProvider());
+        const renderer = this.instantiationService.createInstance(SessionsRenderer);
+        this._register(renderer);
+        const getResourceForElement = (element) => {
+            if (element.id === LocalChatSessionsProvider.CHAT_WIDGET_VIEW_ID) {
+                return null;
+            }
+            return ChatSessionUri.forSession(element.provider.chatSessionType, element.id);
+        };
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'ChatSessions', this.treeContainer, delegate, [renderer], dataSource, {
+            dnd: {
+                onDragStart: (data, originalEvent) => {
+                    try {
+                        const elements = data.getData();
+                        const uris = coalesce(( elements.map(getResourceForElement)));
+                        this.instantiationService.invokeFunction(accessor => fillEditorsDragData(accessor, uris, originalEvent));
+                    }
+                    catch {
+                    }
+                },
+                getDragURI: (element) => {
+                    if (element.id === LocalChatSessionsProvider.HISTORY_NODE_ID) {
+                        return null;
+                    }
+                    return getResourceForElement(element)?.toString() ?? null;
+                },
+                getDragLabel: (elements) => {
+                    if (elements.length === 1) {
+                        return elements[0].label;
+                    }
+                    return localize(5248, "{0} chat sessions", elements.length);
+                },
+                drop: () => { },
+                onDragOver: () => false,
+                dispose: () => { },
+            },
+            accessibilityProvider,
+            identityProvider,
+            multipleSelectionSupport: false,
+            overrideStyles: {
+                listBackground: undefined
+            },
+            paddingBottom: SessionsDelegate.ITEM_HEIGHT,
+            setRowLineHeight: false
+        });
+        this.tree.setInput(this.provider);
+        this._register(this.tree.onDidOpen((e) => {
+            if (e.element) {
+                this.openChatSession(e.element);
+            }
+        }));
+        this._register(this.tree.onContextMenu((e) => {
+            if (e.element && e.element.id !== LocalChatSessionsProvider.HISTORY_NODE_ID) {
+                this.showContextMenu(e);
+            }
+        }));
+        this._register(this.tree.onMouseDblClick(e => {
+            const scrollingByPage = this.configurationService.getValue('workbench.list.scrollByPage');
+            if (e.element === null && !scrollingByPage) {
+                if (this.provider?.chatSessionType && this.provider.chatSessionType !== 'local') {
+                    this.commandService.executeCommand(`workbench.action.chat.openNewSessionEditor.${this.provider?.chatSessionType}`);
+                }
+                else {
+                    this.commandService.executeCommand(ACTION_ID_OPEN_CHAT);
+                }
+            }
+        }));
+        this._register(this.onDidChangeBodyVisibility(async (visible) => {
+            if (visible && this.tree) {
+                await this.loadDataWithProgress();
+            }
+        }));
+        if (this.isBodyVisible() && this.tree) {
+            this.loadDataWithProgress();
+        }
+        this._register(this.tree);
+    }
+    renderGettingStartedList(container) {
+        const listContainer = append(container, $('.getting-started-list-container'));
+        const items = [
+            {
+                id: 'install-extensions',
+                label: ( localize(5249, "Install Chat Extensions")),
+                icon: Codicon.extensions,
+                commandId: 'chat.sessions.gettingStarted'
+            },
+            {
+                id: 'learn-more',
+                label: ( localize(5250, "Learn More About GitHub Copilot coding agent")),
+                commandId: 'vscode.open',
+                icon: Codicon.book,
+                args: [( URI.parse('https://aka.ms/coding-agent-docs'))]
+            }
+        ];
+        const delegate = ( new GettingStartedDelegate());
+        const labels = this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this.onDidChangeBodyVisibility });
+        this._register(labels);
+        const renderer = ( new GettingStartedRenderer(labels));
+        this.list = this.instantiationService.createInstance((WorkbenchList), 'GettingStarted', listContainer, delegate, [renderer], {
+            horizontalScrolling: false,
+        });
+        this.list.splice(0, 0, items);
+        this._register(this.list.onDidOpen(e => {
+            if (e.element) {
+                this.commandService.executeCommand(e.element.commandId, ...(e.element.args ?? []));
+            }
+        }));
+        this._register(this.list);
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        if (this.tree) {
+            this.tree.layout(height, width);
+        }
+        if (this.list) {
+            this.list.layout(height, width);
+        }
+    }
+    async openChatSession(session) {
+        if (!session || !session.id) {
+            return;
+        }
+        try {
+            const uri = ChatSessionUri.forSession(session.provider.chatSessionType, session.id);
+            const existingEditor = findExistingChatEditorByUri(uri, session.id, this.editorGroupsService);
+            if (existingEditor) {
+                await this.editorService.openEditor(existingEditor.editor, existingEditor.groupId);
+                return;
+            }
+            if (this.chatWidgetService.getWidgetBySessionId(session.id)) {
+                return;
+            }
+            if (session.id === LocalChatSessionsProvider.HISTORY_NODE_ID) {
+                return;
+            }
+            if (isLocalChatSessionItem(session)) {
+                const options = {
+                    target: { sessionId: session.id },
+                    pinned: true,
+                    ignoreInView: true,
+                    preserveFocus: true,
+                };
+                await this.editorService.openEditor({ resource: ChatEditorInput.getNewEditorUri(), options });
+                return;
+            }
+            else if (session.id === LocalChatSessionsProvider.CHAT_WIDGET_VIEW_ID) {
+                const chatViewPane = await this.viewsService.openView(ChatViewId);
+                if (chatViewPane) {
+                    await chatViewPane.loadSession(session.id);
+                }
+                return;
+            }
+            const options = {
+                pinned: true,
+                ignoreInView: true,
+                preferredTitle: truncate(session.label, 30),
+                preserveFocus: true,
+            };
+            await this.editorService.openEditor({
+                resource: ChatSessionUri.forSession(session.provider.chatSessionType, session.id),
+                options,
+            });
+        }
+        catch (error) {
+            this.logService.error('[SessionsViewPane] Failed to open chat session:', error);
+        }
+    }
+    showContextMenu(e) {
+        if (!e.element) {
+            return;
+        }
+        const session = e.element;
+        const sessionWithProvider = session;
+        const contextOverlay = getSessionItemContextOverlay(session, sessionWithProvider.provider, this.chatWidgetService, this.chatService, this.editorGroupsService);
+        const contextKeyService = this.contextKeyService.createOverlay(contextOverlay);
+        const marshalledSession = {
+            session: session,
+            $mid: MarshalledId.ChatSessionContext
+        };
+        const menu = this.menuService.createMenu(MenuId.ChatSessionsMenu, contextKeyService);
+        const actions = menu.getActions({ arg: marshalledSession, shouldForwardArgs: true });
+        const { secondary } = getActionBarActions(actions, 'inline');
+        this.contextMenuService.showContextMenu({
+            getActions: () => secondary,
+            getAnchor: () => e.anchor,
+            getActionsContext: () => marshalledSession,
+        });
+        menu.dispose();
+    }
+};
+SessionsViewPane = ( __decorate([
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IViewDescriptorService)),
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IOpenerService)),
+    ( __param(10, IThemeService)),
+    ( __param(11, IHoverService)),
+    ( __param(12, IChatService)),
+    ( __param(13, IEditorService)),
+    ( __param(14, IViewsService)),
+    ( __param(15, ILogService)),
+    ( __param(16, IProgressService)),
+    ( __param(17, IMenuService)),
+    ( __param(18, ICommandService)),
+    ( __param(19, IChatWidgetService)),
+    ( __param(20, IEditorGroupsService))
+], SessionsViewPane));
+
+export { SessionsViewPane };

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

@@ -2,7 +2,6 @@ import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/c
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
-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 { IEditableData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/views";
 import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
@@ -12,7 +11,6 @@ import { ChatSession, IChatSessionContentProvider, IChatSessionItem, IChatSessio
 import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
 export declare class ChatSessionsService extends Disposable implements IChatSessionsService {
     private readonly _logService;
-    private readonly _instantiationService;
     private readonly _chatAgentService;
     private readonly _extensionService;
     private readonly _contextKeyService;
@@ -31,7 +29,7 @@ export declare class ChatSessionsService extends Disposable implements IChatSess
     private readonly _onDidChangeInProgress;
     get onDidChangeInProgress(): Event<void>;
     private readonly inProgressMap;
-    constructor(_logService: ILogService, _instantiationService: IInstantiationService, _chatAgentService: IChatAgentService, _extensionService: IExtensionService, _contextKeyService: IContextKeyService);
+    constructor(_logService: ILogService, _chatAgentService: IChatAgentService, _extensionService: IExtensionService, _contextKeyService: IContextKeyService);
     reportInProgress(chatSessionType: string, count: number): void;
     getInProgress(): {
         displayName: string;
@@ -45,7 +43,7 @@ export declare class ChatSessionsService extends Disposable implements IChatSess
     private _evaluateAvailability;
     private _enableContribution;
     private _disposeSessionsForContribution;
-    private _registerDynamicAgent;
+    private _registerAgent;
     getAllChatSessionContributions(): IChatSessionsExtensionPoint[];
     getAllChatSessionItemProviders(): IChatSessionItemProvider[];
     canResolveItemProvider(chatViewType: string): Promise<boolean>;
@@ -64,8 +62,6 @@ export declare class ChatSessionsService extends Disposable implements IChatSess
      */
     provideNewChatSessionItem(chatSessionType: string, options: {
         request: IChatAgentRequest;
-        prompt?: string;
-        history?: any[];
         metadata?: any;
     }, token: CancellationToken): Promise<IChatSessionItem>;
     provideChatSessionContent(chatSessionType: string, id: string, token: CancellationToken): Promise<ChatSession>;