@codingame/monaco-vscode-chat-service-override 19.1.4 → 20.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminalChatActions.js

@@ -0,0 +1,262 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { AbstractInline1ChatAction } from '../../../inlineChat/browser/inlineChatActions.js';
+import { isDetachedTerminalInstance } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal';
+import { registerActiveXtermAction } from '@codingame/monaco-vscode-07eaa805-9dea-5ec6-a422-a4f04872424d-common/vscode/vs/workbench/contrib/terminal/browser/terminalActions';
+import { TerminalContextKeys } from '@codingame/monaco-vscode-262ed59d-4f76-57cd-9e9f-1877f26ae049-common/vscode/vs/workbench/contrib/terminal/common/terminalContextKey';
+import { TerminalChatContextKeys, TerminalChatCommandId, MENU_TERMINAL_CHAT_WIDGET_STATUS } from '@codingame/monaco-vscode-07eaa805-9dea-5ec6-a422-a4f04872424d-common/vscode/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat';
+import { TerminalChatController } from './terminalChatController.js';
+import { activeChatController } from './terminalChatControllerHolder.js';
+
+registerActiveXtermAction({
+    id: TerminalChatCommandId.Start,
+    title: ( localize2(11240, 'Terminal Inline Chat')),
+    category: AbstractInline1ChatAction.category,
+    keybinding: {
+        primary: KeyMod.CtrlCmd | KeyCode.KeyI,
+        when: ( ContextKeyExpr.and(TerminalContextKeys.focusInAny)),
+        weight: KeybindingWeight.ExternalExtension + 1,
+    },
+    f1: true,
+    precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), TerminalChatContextKeys.hasChatAgent)),
+    menu: {
+        id: MenuId.ChatTerminalMenu,
+        group: 'copilot',
+        order: 1
+    },
+    run: (_xterm, _accessor, activeInstance, opts) => {
+        if (isDetachedTerminalInstance(activeInstance)) {
+            return;
+        }
+        const contr = activeChatController || TerminalChatController.get(activeInstance);
+        if (opts) {
+            opts = typeof opts === 'string' ? { query: opts } : opts;
+            if (typeof opts === 'object' && opts !== null && 'query' in opts && typeof opts.query === 'string') {
+                contr?.updateInput(opts.query, false);
+                if (!('isPartialQuery' in opts && opts.isPartialQuery)) {
+                    contr?.terminalChatWidget?.acceptInput();
+                }
+            }
+        }
+        contr?.terminalChatWidget?.reveal();
+    }
+});
+registerActiveXtermAction({
+    id: TerminalChatCommandId.Close,
+    title: ( localize2(11241, 'Close')),
+    category: AbstractInline1ChatAction.category,
+    keybinding: {
+        primary: KeyCode.Escape,
+        when: ( ContextKeyExpr.and(( ContextKeyExpr.or(TerminalContextKeys.focus, TerminalChatContextKeys.focused)), TerminalChatContextKeys.visible)),
+        weight: KeybindingWeight.WorkbenchContrib,
+    },
+    menu: [{
+            id: MENU_TERMINAL_CHAT_WIDGET_STATUS,
+            group: '0_main',
+            order: 2,
+        }],
+    icon: Codicon.close,
+    f1: true,
+    precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, TerminalChatContextKeys.visible)),
+    run: (_xterm, _accessor, activeInstance) => {
+        if (isDetachedTerminalInstance(activeInstance)) {
+            return;
+        }
+        const contr = activeChatController || TerminalChatController.get(activeInstance);
+        contr?.terminalChatWidget?.clear();
+    }
+});
+registerActiveXtermAction({
+    id: TerminalChatCommandId.RunCommand,
+    title: ( localize2(11242, 'Run Chat Command')),
+    shortTitle: ( localize2(11243, 'Run')),
+    category: AbstractInline1ChatAction.category,
+    precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), ( TerminalChatContextKeys.requestActive.negate()), TerminalChatContextKeys.responseContainsCodeBlock, ( TerminalChatContextKeys.responseContainsMultipleCodeBlocks.negate()))),
+    icon: Codicon.play,
+    keybinding: {
+        when: ( TerminalChatContextKeys.requestActive.negate()),
+        weight: KeybindingWeight.WorkbenchContrib,
+        primary: KeyMod.CtrlCmd | KeyCode.Enter,
+    },
+    menu: {
+        id: MENU_TERMINAL_CHAT_WIDGET_STATUS,
+        group: '0_main',
+        order: 0,
+        when: ( ContextKeyExpr.and(TerminalChatContextKeys.responseContainsCodeBlock, ( TerminalChatContextKeys.responseContainsMultipleCodeBlocks.negate()), ( TerminalChatContextKeys.requestActive.negate())))
+    },
+    run: (_xterm, _accessor, activeInstance) => {
+        if (isDetachedTerminalInstance(activeInstance)) {
+            return;
+        }
+        const contr = activeChatController || TerminalChatController.get(activeInstance);
+        contr?.terminalChatWidget?.acceptCommand(true);
+    }
+});
+registerActiveXtermAction({
+    id: TerminalChatCommandId.RunFirstCommand,
+    title: ( localize2(11244, 'Run First Chat Command')),
+    shortTitle: ( localize2(11245, 'Run First')),
+    category: AbstractInline1ChatAction.category,
+    precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), ( TerminalChatContextKeys.requestActive.negate()), TerminalChatContextKeys.responseContainsMultipleCodeBlocks)),
+    icon: Codicon.play,
+    keybinding: {
+        when: ( TerminalChatContextKeys.requestActive.negate()),
+        weight: KeybindingWeight.WorkbenchContrib,
+        primary: KeyMod.CtrlCmd | KeyCode.Enter,
+    },
+    menu: {
+        id: MENU_TERMINAL_CHAT_WIDGET_STATUS,
+        group: '0_main',
+        order: 0,
+        when: ( ContextKeyExpr.and(TerminalChatContextKeys.responseContainsMultipleCodeBlocks, ( TerminalChatContextKeys.requestActive.negate())))
+    },
+    run: (_xterm, _accessor, activeInstance) => {
+        if (isDetachedTerminalInstance(activeInstance)) {
+            return;
+        }
+        const contr = activeChatController || TerminalChatController.get(activeInstance);
+        contr?.terminalChatWidget?.acceptCommand(true);
+    }
+});
+registerActiveXtermAction({
+    id: TerminalChatCommandId.InsertCommand,
+    title: ( localize2(11246, 'Insert Chat Command')),
+    shortTitle: ( localize2(11247, 'Insert')),
+    category: AbstractInline1ChatAction.category,
+    icon: Codicon.insert,
+    precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), ( TerminalChatContextKeys.requestActive.negate()), TerminalChatContextKeys.responseContainsCodeBlock, ( TerminalChatContextKeys.responseContainsMultipleCodeBlocks.negate()))),
+    keybinding: {
+        when: ( TerminalChatContextKeys.requestActive.negate()),
+        weight: KeybindingWeight.WorkbenchContrib,
+        primary: KeyMod.Alt | KeyCode.Enter,
+        secondary: [KeyMod.CtrlCmd | KeyCode.Enter | KeyMod.Alt]
+    },
+    menu: {
+        id: MENU_TERMINAL_CHAT_WIDGET_STATUS,
+        group: '0_main',
+        order: 1,
+        when: ( ContextKeyExpr.and(TerminalChatContextKeys.responseContainsCodeBlock, ( TerminalChatContextKeys.responseContainsMultipleCodeBlocks.negate()), ( TerminalChatContextKeys.requestActive.negate())))
+    },
+    run: (_xterm, _accessor, activeInstance) => {
+        if (isDetachedTerminalInstance(activeInstance)) {
+            return;
+        }
+        const contr = activeChatController || TerminalChatController.get(activeInstance);
+        contr?.terminalChatWidget?.acceptCommand(false);
+    }
+});
+registerActiveXtermAction({
+    id: TerminalChatCommandId.InsertFirstCommand,
+    title: ( localize2(11248, 'Insert First Chat Command')),
+    shortTitle: ( localize2(11249, 'Insert First')),
+    category: AbstractInline1ChatAction.category,
+    precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), ( TerminalChatContextKeys.requestActive.negate()), TerminalChatContextKeys.responseContainsMultipleCodeBlocks)),
+    keybinding: {
+        when: ( TerminalChatContextKeys.requestActive.negate()),
+        weight: KeybindingWeight.WorkbenchContrib,
+        primary: KeyMod.Alt | KeyCode.Enter,
+        secondary: [KeyMod.CtrlCmd | KeyCode.Enter | KeyMod.Alt]
+    },
+    menu: {
+        id: MENU_TERMINAL_CHAT_WIDGET_STATUS,
+        group: '0_main',
+        order: 1,
+        when: ( ContextKeyExpr.and(TerminalChatContextKeys.responseContainsMultipleCodeBlocks, ( TerminalChatContextKeys.requestActive.negate())))
+    },
+    run: (_xterm, _accessor, activeInstance) => {
+        if (isDetachedTerminalInstance(activeInstance)) {
+            return;
+        }
+        const contr = activeChatController || TerminalChatController.get(activeInstance);
+        contr?.terminalChatWidget?.acceptCommand(false);
+    }
+});
+registerActiveXtermAction({
+    id: TerminalChatCommandId.RerunRequest,
+    title: ( localize2(11250, "Rerun Request")),
+    f1: false,
+    icon: Codicon.refresh,
+    category: AbstractInline1ChatAction.category,
+    precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), ( TerminalChatContextKeys.requestActive.negate()))),
+    keybinding: {
+        weight: KeybindingWeight.WorkbenchContrib,
+        primary: KeyMod.CtrlCmd | KeyCode.KeyR,
+        when: TerminalChatContextKeys.focused
+    },
+    menu: {
+        id: MENU_TERMINAL_CHAT_WIDGET_STATUS,
+        group: '0_main',
+        order: 5,
+        when: ( ContextKeyExpr.and(( TerminalChatContextKeys.inputHasText.toNegated()), ( TerminalChatContextKeys.requestActive.negate())))
+    },
+    run: async (_xterm, _accessor, activeInstance) => {
+        const chatService = _accessor.get(IChatService);
+        const chatWidgetService = _accessor.get(IChatWidgetService);
+        const contr = activeChatController;
+        const model = contr?.terminalChatWidget?.inlineChatWidget.chatWidget.viewModel?.model;
+        if (!model) {
+            return;
+        }
+        const lastRequest = model.getRequests().at(-1);
+        if (lastRequest) {
+            const widget = chatWidgetService.getWidgetBySessionId(model.sessionId);
+            await chatService.resendRequest(lastRequest, {
+                noCommandDetection: false,
+                attempt: lastRequest.attempt + 1,
+                location: ChatAgentLocation.Terminal,
+                userSelectedModelId: widget?.input.currentLanguageModel
+            });
+        }
+    }
+});
+registerActiveXtermAction({
+    id: TerminalChatCommandId.ViewInChat,
+    title: ( localize2(11251, 'View in Chat')),
+    category: AbstractInline1ChatAction.category,
+    precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), ( TerminalChatContextKeys.requestActive.negate()))),
+    icon: Codicon.commentDiscussion,
+    menu: [{
+            id: MENU_TERMINAL_CHAT_WIDGET_STATUS,
+            group: 'zzz',
+            order: 1,
+            isHiddenByDefault: true,
+            when: ( ContextKeyExpr.and(TerminalChatContextKeys.responseContainsCodeBlock, ( TerminalChatContextKeys.requestActive.negate()))),
+        }],
+    run: (_xterm, _accessor, activeInstance) => {
+        if (isDetachedTerminalInstance(activeInstance)) {
+            return;
+        }
+        const contr = activeChatController || TerminalChatController.get(activeInstance);
+        contr?.viewInChat();
+    }
+});

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

@@ -0,0 +1,35 @@
+import type { Terminal as RawXtermTerminal } from "@xterm/xterm";
+import { Disposable } 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 { IChatCodeBlockContextProviderService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { ITerminalContribution, ITerminalInstance, IXtermTerminal } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { TerminalChatWidget } from "./terminalChatWidget.js";
+import type { ITerminalContributionContext } from "@codingame/monaco-vscode-88141f48-1af9-57ef-a278-f4b2ff6128fa-common/vscode/vs/workbench/contrib/terminal/browser/terminalExtensions";
+export declare class TerminalChatController extends Disposable implements ITerminalContribution {
+    private readonly _ctx;
+    private readonly _contextKeyService;
+    private readonly _instantiationService;
+    private readonly _terminalService;
+    static readonly ID = "terminal.chat";
+    static get(instance: ITerminalInstance): TerminalChatController | null;
+    private _terminalChatWidget;
+    get terminalChatWidget(): TerminalChatWidget | undefined;
+    private _lastResponseContent;
+    get lastResponseContent(): string | undefined;
+    get scopedContextKeyService(): IContextKeyService;
+    constructor(_ctx: ITerminalContributionContext, chatCodeBlockContextProviderService: IChatCodeBlockContextProviderService, _contextKeyService: IContextKeyService, _instantiationService: IInstantiationService, _terminalService: ITerminalService);
+    xtermReady(xterm: IXtermTerminal & {
+        raw: RawXtermTerminal;
+    }): void;
+    private _forcedPlaceholder;
+    private _updatePlaceholder;
+    private _getPlaceholderText;
+    setPlaceholder(text: string): void;
+    resetPlaceholder(): void;
+    updateInput(text: string, selectAll?: boolean): void;
+    focus(): void;
+    hasFocus(): boolean;
+    viewInChat(): Promise<void>;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminalChatController.js

@@ -0,0 +1,129 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { Disposable } 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 { showChatView } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IChatCodeBlockContextProviderService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { isDetachedTerminalInstance } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal';
+import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { TerminalChatWidget } from './terminalChatWidget.js';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { setActiveChatController } from './terminalChatControllerHolder.js';
+
+var TerminalChatController_1;
+let TerminalChatController = class TerminalChatController extends Disposable {
+    static { TerminalChatController_1 = this; }
+    static { this.ID = 'terminal.chat'; }
+    static get(instance) {
+        return instance.getContribution(TerminalChatController_1.ID);
+    }
+    get terminalChatWidget() { return this._terminalChatWidget?.value; }
+    get lastResponseContent() {
+        return this._lastResponseContent;
+    }
+    get scopedContextKeyService() {
+        return this._terminalChatWidget?.value.inlineChatWidget.scopedContextKeyService ?? this._contextKeyService;
+    }
+    constructor(_ctx, chatCodeBlockContextProviderService, _contextKeyService, _instantiationService, _terminalService) {
+        super();
+        this._ctx = _ctx;
+        this._contextKeyService = _contextKeyService;
+        this._instantiationService = _instantiationService;
+        this._terminalService = _terminalService;
+        this._forcedPlaceholder = undefined;
+        this._register(chatCodeBlockContextProviderService.registerProvider({
+            getCodeBlockContext: (editor) => {
+                if (!editor || !this._terminalChatWidget?.hasValue || !this.hasFocus()) {
+                    return;
+                }
+                return {
+                    element: editor,
+                    code: editor.getValue(),
+                    codeBlockIndex: 0,
+                    languageId: editor.getModel().getLanguageId(),
+                    chatSessionId: this._terminalChatWidget.value.inlineChatWidget.chatWidget.viewModel?.sessionId
+                };
+            }
+        }, 'terminal'));
+    }
+    xtermReady(xterm) {
+        this._terminalChatWidget = ( new Lazy(() => {
+            const chatWidget = this._register(this._instantiationService.createInstance(TerminalChatWidget, this._ctx.instance.domElement, this._ctx.instance, xterm));
+            this._register(chatWidget.focusTracker.onDidFocus(() => {
+                setActiveChatController(this);
+                if (!isDetachedTerminalInstance(this._ctx.instance)) {
+                    this._terminalService.setActiveInstance(this._ctx.instance);
+                }
+            }));
+            this._register(chatWidget.focusTracker.onDidBlur(() => {
+                setActiveChatController(undefined);
+                this._ctx.instance.resetScrollbarVisibility();
+            }));
+            if (!this._ctx.instance.domElement) {
+                throw ( new Error('FindWidget expected terminal DOM to be initialized'));
+            }
+            return chatWidget;
+        }));
+    }
+    _updatePlaceholder() {
+        const inlineChatWidget = this._terminalChatWidget?.value.inlineChatWidget;
+        if (inlineChatWidget) {
+            inlineChatWidget.placeholder = this._getPlaceholderText();
+        }
+    }
+    _getPlaceholderText() {
+        return this._forcedPlaceholder ?? '';
+    }
+    setPlaceholder(text) {
+        this._forcedPlaceholder = text;
+        this._updatePlaceholder();
+    }
+    resetPlaceholder() {
+        this._forcedPlaceholder = undefined;
+        this._updatePlaceholder();
+    }
+    updateInput(text, selectAll = true) {
+        const widget = this._terminalChatWidget?.value.inlineChatWidget;
+        if (widget) {
+            widget.value = text;
+            if (selectAll) {
+                widget.selectAll();
+            }
+        }
+    }
+    focus() {
+        this._terminalChatWidget?.value.focus();
+    }
+    hasFocus() {
+        return this._terminalChatWidget?.rawValue?.hasFocus() ?? false;
+    }
+    async viewInChat() {
+        const chatModel = this.terminalChatWidget?.inlineChatWidget.chatWidget.viewModel?.model;
+        if (chatModel) {
+            await this._instantiationService.invokeFunction(moveToPanelChat, chatModel);
+        }
+        this._terminalChatWidget?.rawValue?.hide();
+    }
+};
+TerminalChatController = TerminalChatController_1 = ( __decorate([
+    ( __param(1, IChatCodeBlockContextProviderService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ITerminalService))
+], TerminalChatController));
+async function moveToPanelChat(accessor, model) {
+    const viewsService = accessor.get(IViewsService);
+    const chatService = accessor.get(IChatService);
+    const widget = await showChatView(viewsService);
+    if (widget && widget.viewModel && model) {
+        for (const request of model.getRequests().slice()) {
+            await chatService.adoptRequest(widget.viewModel.model.sessionId, request);
+        }
+        widget.focusLastMessage();
+    }
+}
+
+export { TerminalChatController };

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

@@ -0,0 +1,3 @@
+import { TerminalChatController } from "./terminalChatController.js";
+export declare let activeChatController: TerminalChatController | undefined;
+export declare function setActiveChatController(_activeChatController: TerminalChatController | undefined): void;

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminalChatControllerHolder.js

@@ -0,0 +1,8 @@
+
+
+let activeChatController;
+function setActiveChatController(_activeChatController) {
+    activeChatController = _activeChatController;
+}
+
+export { activeChatController, setActiveChatController };

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

@@ -0,0 +1,9 @@
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
+export declare class TerminalChatEnabler {
+    static Id: string;
+    private readonly _ctxHasProvider;
+    private readonly _store;
+    constructor(chatAgentService: IChatAgentService, contextKeyService: IContextKeyService);
+    dispose(): void;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminalChatEnabler.js

@@ -0,0 +1,30 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore } 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 { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { TerminalChatContextKeys } from '@codingame/monaco-vscode-07eaa805-9dea-5ec6-a422-a4f04872424d-common/vscode/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat';
+
+let TerminalChatEnabler = class TerminalChatEnabler {
+    static { this.Id = 'terminalChat.enabler'; }
+    constructor(chatAgentService, contextKeyService) {
+        this._store = ( new DisposableStore());
+        this._ctxHasProvider = TerminalChatContextKeys.hasChatAgent.bindTo(contextKeyService);
+        this._store.add(Event.runAndSubscribe(chatAgentService.onDidChangeAgents, () => {
+            const hasTerminalAgent = Boolean(chatAgentService.getDefaultAgent(ChatAgentLocation.Terminal));
+            this._ctxHasProvider.set(hasTerminalAgent);
+        }));
+    }
+    dispose() {
+        this._ctxHasProvider.reset();
+        this._store.dispose();
+    }
+};
+TerminalChatEnabler = ( __decorate([
+    ( __param(0, IChatAgentService)),
+    ( __param(1, IContextKeyService))
+], TerminalChatEnabler));
+
+export { TerminalChatEnabler };

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

@@ -0,0 +1,72 @@
+import type { Terminal as RawXtermTerminal } from "@xterm/xterm";
+import { IFocusTracker } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+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 { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IViewsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service";
+import { IChatAcceptInputOptions } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chat";
+import type { IChatViewState } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/browser/chatWidget";
+import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
+import { IChatResponseModel } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { InlineChatWidget } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatWidget";
+import { ITerminalInstance, type IXtermTerminal } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+export declare class TerminalChatWidget extends Disposable {
+    private readonly _terminalElement;
+    private readonly _instance;
+    private readonly _xterm;
+    private readonly _chatService;
+    private readonly _storageService;
+    private readonly _viewsService;
+    private readonly _chatAgentService;
+    private readonly _container;
+    private readonly _onDidHide;
+    readonly onDidHide: Event<void>;
+    private readonly _inlineChatWidget;
+    get inlineChatWidget(): InlineChatWidget;
+    private readonly _focusTracker;
+    private readonly _focusedContextKey;
+    private readonly _visibleContextKey;
+    private readonly _requestActiveContextKey;
+    private readonly _responseContainsCodeBlockContextKey;
+    private readonly _responseContainsMulitpleCodeBlocksContextKey;
+    private _messages;
+    private _viewStateStorageKey;
+    private _lastResponseContent;
+    get lastResponseContent(): string | undefined;
+    private _terminalAgentName;
+    private readonly _model;
+    private _sessionCtor;
+    private _currentRequestId;
+    private _activeRequestCts?;
+    private readonly _requestInProgress;
+    readonly requestInProgress: IObservable<boolean>;
+    constructor(_terminalElement: HTMLElement, _instance: ITerminalInstance, _xterm: IXtermTerminal & {
+        raw: RawXtermTerminal;
+    }, contextKeyService: IContextKeyService, _chatService: IChatService, _storageService: IStorageService, _viewsService: IViewsService, instantiationService: IInstantiationService, _chatAgentService: IChatAgentService);
+    private _dimension?;
+    private _relayout;
+    private _doLayout;
+    private _resetPlaceholder;
+    reveal(viewState?: IChatViewState): Promise<void>;
+    private _getTerminalCursorTop;
+    private _updateXtermViewportPosition;
+    private _getTerminalViewportHeight;
+    hide(): void;
+    private _setTerminalViewportOffset;
+    focus(): void;
+    hasFocus(): boolean;
+    setValue(value?: string): void;
+    acceptCommand(shouldExecute: boolean): Promise<void>;
+    get focusTracker(): IFocusTracker;
+    private _createSession;
+    private _loadViewState;
+    private _saveViewState;
+    clear(): void;
+    acceptInput(query?: string, options?: IChatAcceptInputOptions): Promise<IChatResponseModel | undefined>;
+    cancel(): void;
+    viewInChat(): Promise<void>;
+}