@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/contrib/automations/browser/automationDialogService.d.ts

@@ -0,0 +1,32 @@
+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 { 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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IWorkspaceTrustRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IAutomationDialogResult, IShowAutomationDialogOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationDialogService";
+import { IAutomationDialogService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationDialogService.service";
+import { IHostService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service";
+import { IWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+/**
+ * Owns the Automations create/edit dialog in the sessions layer, where the
+ * session-type provider it needs already lives. The workbench list widget
+ * depends only on {@link IAutomationDialogService}.
+ */
+export declare class AutomationDialogService implements IAutomationDialogService {
+    private readonly instantiationService;
+    private readonly contextKeyService;
+    private readonly contextViewService;
+    private readonly configurationService;
+    private readonly keybindingService;
+    private readonly layoutService;
+    private readonly logService;
+    private readonly hostService;
+    private readonly sessionsManagementService;
+    private readonly workspaceTrustRequestService;
+    readonly _serviceBrand: undefined;
+    constructor(instantiationService: IInstantiationService, contextKeyService: IContextKeyService, contextViewService: IContextViewService, configurationService: IConfigurationService, keybindingService: IKeybindingService, layoutService: IWorkbenchLayoutService, logService: ILogService, hostService: IHostService, sessionsManagementService: ISessionsManagementService, workspaceTrustRequestService: IWorkspaceTrustRequestService);
+    showAutomationDialog(options: IShowAutomationDialogOptions): Promise<IAutomationDialogResult | undefined>;
+}

package/vscode/src/vs/sessions/contrib/automations/browser/automationDialogService.js

@@ -0,0 +1,396 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as automationDialog from './media/automationDialog.css';
+import { $ as $$1, append, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { ButtonBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { Dialog } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/dialog/dialog';
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { DisposableStore, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isWindows } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+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 { 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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IWorkspaceTrustRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { defaultButtonStyles, defaultDialogStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { createWorkbenchDialogOptions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/dialogs/dialog';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { renderForm, registerAutomationDialogKeyboardNavigation, isAutomationDialogPopupTarget, updateSaveButtonState, shouldPassThroughAutomationDialogCommand } from './automationDialog.js';
+
+registerCss(automationDialog, 1);
+const $ = $$1;
+const automationDialogAllowableCommands = ( new Set([
+    "workbench.action.quit",
+    "workbench.action.reloadWindow",
+    "copy",
+    "cut",
+    "paste",
+    "editor.action.selectAll",
+    "editor.action.clipboardCopyAction",
+    "editor.action.clipboardCutAction",
+    "editor.action.clipboardPasteAction",
+    "hideCodeActionWidget",
+    "clearFilterCodeActionWidget",
+    "selectPrevCodeAction",
+    "selectNextCodeAction",
+    "acceptSelectedCodeAction",
+    "previewSelectedCodeAction",
+    "toggleSectionCodeAction",
+    "collapseSectionCodeAction",
+    "expandSectionCodeAction",
+    "quickInput.next",
+    "quickInput.previous",
+    "quickInput.accept",
+    "quickInput.hide"
+]));
+let AutomationDialogService = class AutomationDialogService {
+    constructor(
+        instantiationService,
+        contextKeyService,
+        contextViewService,
+        configurationService,
+        keybindingService,
+        layoutService,
+        logService,
+        hostService,
+        sessionsManagementService,
+        workspaceTrustRequestService
+    ) {
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.contextViewService = contextViewService;
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.layoutService = layoutService;
+        this.logService = logService;
+        this.hostService = hostService;
+        this.sessionsManagementService = sessionsManagementService;
+        this.workspaceTrustRequestService = workspaceTrustRequestService;
+    }
+    async showAutomationDialog(options) {
+        const disposables = ( new DisposableStore());
+        const existing = options.existing;
+        const initial = existing ?? options.initialValues;
+        const isEdit = !!existing;
+        const initialTarget = initial?.target;
+        const initialWorkspaceTarget = initialTarget?.kind === "workspace" ? initialTarget : undefined;
+        const initialSessionConfiguration = initial ? {
+            sessionTemplate: initial.sessionTemplate,
+            modelId: initial.modelId,
+            mode: initial.mode,
+            permissionLevel: initial.permissionLevel
+        } : undefined;
+        const state = {
+            name: initial?.name ?? "",
+            interval: initial?.schedule.interval ?? "daily",
+            hour: initial?.schedule.scheduleHour ?? 9,
+            minute: initial?.schedule.scheduleMinute ?? 0,
+            day: initial?.schedule.scheduleDay ?? 1,
+            isQuickChat: initialTarget?.kind === "quickChat",
+            folderUri: initialWorkspaceTarget?.folderUri,
+            providerId: initialTarget?.providerId,
+            sessionTypeId: initialTarget?.sessionTypeId,
+            isolationMode: initialWorkspaceTarget?.isolation.kind === "default" ? undefined : initialWorkspaceTarget?.isolation.kind === "worktree" ? "worktree" : "workspace",
+            branch: initialWorkspaceTarget?.isolation.kind === "worktree" ? initialWorkspaceTarget.isolation.branch : undefined,
+            enabled: initial?.enabled ?? true
+        };
+        const validation = {
+            nameError: undefined,
+            promptError: undefined,
+            folderError: undefined,
+            sessionTypeError: undefined,
+            branchError: undefined
+        };
+        let saveButton;
+        let cancelButton;
+        let revalidate = () => {};
+        let getPrompt = () => initial?.prompt ?? "";
+        let getSessionConfiguration = async () => ({
+            kind: "preserved",
+            configuration: initialSessionConfiguration
+        });
+        let getBranch = () => initialWorkspaceTarget?.isolation.kind === "worktree" ? initialWorkspaceTarget.isolation.branch : undefined;
+        let waitForAutomationSessionSync = async () => {};
+        let setSaving = () => {};
+        let showSessionConfigurationError = () => {};
+        let focusSessionConfigurationError = () => {};
+        let getFocusableElements = () => [];
+        let focusFirst = () => {};
+        let saveInProgress = false;
+        const saveCancellation = disposables.add(( new MutableDisposable()));
+        const completion = ( new DeferredPromise());
+        const title = isEdit ? ( localize(3326, "Edit automation")) : ( localize(3327, "New automation"));
+        const saveButtonLabel = isEdit ? ( localize(3328, "Save")) : ( localize(3329, "Create"));
+        const cancelButtonLabel = ( localize(3330, "Cancel"));
+        const savingButtonLabel = ( localize(3331, "Saving…"));
+        const captureErrorMessage = ( localize(
+            3332,
+            "The automation wasn't saved because its session configuration couldn't be captured. Check the provider connection and try again."
+        ));
+        const buildResult = sessionConfigurationCapture => {
+            const schedule = {
+                interval: state.interval,
+                scheduleHour: state.hour,
+                scheduleMinute: state.minute,
+                scheduleDay: state.day
+            };
+            const prompt = getPrompt();
+            const sessionConfiguration = sessionConfigurationCapture.configuration;
+            const sessionTemplate = sessionConfiguration?.sessionTemplate;
+            const target = createAutomationTarget(state, getBranch());
+            if (!target) {
+                return undefined;
+            }
+            if (existing) {
+                const patch = {
+                    name: state.name,
+                    prompt,
+                    schedule,
+                    target,
+                    ...(sessionConfigurationCapture.kind === "captured" ? {
+                        sessionTemplate: sessionTemplate ?? null
+                    } : {}),
+                    enabled: state.enabled
+                };
+                return {
+                    kind: "update",
+                    id: existing.id,
+                    value: patch
+                };
+            }
+            const create = {
+                name: state.name,
+                prompt,
+                schedule,
+                target,
+                ...(sessionTemplate ? {
+                    sessionTemplate
+                } : sessionConfiguration ? {
+                    ...(sessionConfiguration.modelId !== undefined ? {
+                        modelId: sessionConfiguration.modelId
+                    } : {}),
+                    ...(sessionConfiguration.mode !== undefined ? {
+                        mode: sessionConfiguration.mode
+                    } : {}),
+                    ...(sessionConfiguration.permissionLevel !== undefined ? {
+                        permissionLevel: sessionConfiguration.permissionLevel
+                    } : {})
+                } : {}),
+                enabled: state.enabled
+            };
+            return {
+                kind: "create",
+                value: create
+            };
+        };
+        const closeDialog = result => {
+            if (completion.isSettled) {
+                return;
+            }
+            saveCancellation.value?.cancel();
+            void completion.complete(result);
+            dialog.dispose();
+        };
+        const save = async () => {
+            if (saveInProgress) {
+                return;
+            }
+            revalidate();
+            if (validation.nameError || validation.promptError || validation.folderError || validation.sessionTypeError || validation.branchError) {
+                return;
+            }
+            if ((!state.isQuickChat && !state.folderUri) || !state.sessionTypeId || (state.isQuickChat && !state.providerId)) {
+                return;
+            }
+            saveInProgress = true;
+            showSessionConfigurationError(undefined);
+            setSaving(true);
+            if (saveButton) {
+                saveButton.enabled = false;
+                saveButton.label = savingButtonLabel;
+            }
+            cancelButton?.focus();
+            const cancellation = ( new CancellationTokenSource());
+            saveCancellation.value = cancellation;
+            let shouldClose = false;
+            let shouldFocusError = false;
+            try {
+                await waitForAutomationSessionSync(cancellation.token);
+                const sessionConfigurationCapture = await getSessionConfiguration(cancellation.token);
+                if (sessionConfigurationCapture.kind === "failed") {
+                    showSessionConfigurationError(captureErrorMessage);
+                    shouldFocusError = true;
+                    return;
+                }
+                const result = buildResult(sessionConfigurationCapture);
+                if (result) {
+                    shouldClose = true;
+                    closeDialog(result);
+                }
+            } catch (error) {
+                if (!isCancellationError(error) && !cancellation.token.isCancellationRequested) {
+                    this.logService.error(
+                        "[AutomationDialog] Failed to save the automation session configuration.",
+                        error
+                    );
+                    showSessionConfigurationError(captureErrorMessage);
+                    shouldFocusError = true;
+                }
+            } finally {
+                if (saveCancellation.value === cancellation) {
+                    saveCancellation.clear();
+                }
+                saveInProgress = false;
+                if (!shouldClose && !completion.isSettled) {
+                    setSaving(false);
+                    if (saveButton) {
+                        saveButton.label = saveButtonLabel;
+                    }
+                    revalidate();
+                    if (shouldFocusError) {
+                        focusSessionConfigurationError();
+                    }
+                }
+            }
+        };
+        const activeContainer = this.layoutService.activeContainer;
+        const dialog = disposables.add(( new Dialog(activeContainer, title, [], createWorkbenchDialogOptions({
+            type: "none",
+            extraClasses: ["automation-dialog"],
+            disableDefaultAction: true,
+            isExternalFocusAllowed: isAutomationDialogPopupTarget,
+            dialogStyles: {
+                ...defaultDialogStyles,
+                textLinkForeground: undefined
+            },
+            renderFooter: container => {
+                container.classList.add("dialog-buttons", "automation-dialog-footer-actions");
+                container.parentElement?.classList.add("dialog-buttons-row", "automation-dialog-footer-row");
+                const buttonBar = disposables.add(( new ButtonBar(container)));
+                const createSaveButton = () => {
+                    saveButton = buttonBar.addButton(defaultButtonStyles);
+                    saveButton.label = saveButtonLabel;
+                    disposables.add(saveButton.onDidClick(() => void save()));
+                };
+                const createCancelButton = () => {
+                    cancelButton = buttonBar.addButton({
+                        ...defaultButtonStyles,
+                        secondary: true
+                    });
+                    cancelButton.label = cancelButtonLabel;
+                    disposables.add(cancelButton.onDidClick(() => closeDialog(undefined)));
+                };
+                if (isWindows) {
+                    createSaveButton();
+                    createCancelButton();
+                } else {
+                    createCancelButton();
+                    createSaveButton();
+                }
+            },
+            renderBody: container => {
+                container.classList.add("automation-dialog-body");
+                const titlebar = append(container, $(".automation-titlebar"));
+                titlebar.setAttribute("aria-hidden", "true");
+                titlebar.textContent = title;
+                const description = append(container, $(".automation-description"));
+                description.textContent = isEdit ? ( localize(3333, "Update the schedule, prompt, or run target for this automation.")) : ( localize(
+                    3334,
+                    "Define a prompt that will run on a schedule against the selected target."
+                ));
+                const formPane = append(container, $(".automation-form-pane"));
+                const form = append(formPane, $(".automation-form"));
+                const handle = renderForm(
+                    form,
+                    state,
+                    disposables,
+                    validation,
+                    () => revalidate(),
+                    this.instantiationService,
+                    this.contextKeyService,
+                    this.contextViewService,
+                    this.configurationService,
+                    this.layoutService,
+                    this.logService,
+                    this.sessionsManagementService,
+                    this.workspaceTrustRequestService,
+                    initial?.prompt ?? "",
+                    initialTarget,
+                    initialSessionConfiguration
+                );
+                getPrompt = handle.getPrompt;
+                getSessionConfiguration = handle.getSessionConfiguration;
+                getBranch = handle.getBranch;
+                waitForAutomationSessionSync = handle.waitForAutomationSessionSync;
+                setSaving = handle.setSaving;
+                showSessionConfigurationError = handle.showSessionConfigurationError;
+                focusSessionConfigurationError = handle.focusSessionConfigurationError;
+                getFocusableElements = handle.getFocusableElements;
+                const keyboardNavigation = disposables.add(
+                    registerAutomationDialogKeyboardNavigation(getWindow(container), () => [
+                        ...getFocusableElements(),
+                        ...(saveButton ? [saveButton.element] : []),
+                        ...(cancelButton ? [cancelButton.element] : [])
+                    ], isAutomationDialogPopupTarget, handle.acceptPromptSuggestion, handle.cancelPromptSuggestion)
+                );
+                focusFirst = keyboardNavigation.focusFirst;
+                revalidate = () => {
+                    updateSaveButtonState(saveButton, state, validation, form, getPrompt, getBranch);
+                    if (saveInProgress && saveButton) {
+                        saveButton.enabled = false;
+                    }
+                };
+                revalidate();
+            }
+        }, this.keybindingService, this.layoutService, this.hostService, automationDialogAllowableCommands, (commandId, event) => shouldPassThroughAutomationDialogCommand(commandId, event.target)))));
+        activeContainer.classList.add("automation-dialog-open");
+        disposables.add(
+            toDisposable(() => activeContainer.classList.remove("automation-dialog-open"))
+        );
+        try {
+            void dialog.show().then(() => closeDialog(undefined));
+            focusFirst();
+            return await completion.p;
+        } finally {
+            disposables.dispose();
+        }
+    }
+};
+AutomationDialogService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IContextKeyService)), ( __param(2, IContextViewService)), ( __param(3, IConfigurationService)), ( __param(4, IKeybindingService)), ( __param(5, IWorkbenchLayoutService)), ( __param(6, ILogService)), ( __param(7, IHostService)), ( __param(8, ISessionsManagementService)), ( __param(9, IWorkspaceTrustRequestService))], AutomationDialogService));
+function createAutomationTarget(state, branch) {
+    if (state.isQuickChat) {
+        return state.providerId && state.sessionTypeId ? {
+            kind: "quickChat",
+            providerId: state.providerId,
+            sessionTypeId: state.sessionTypeId
+        } : undefined;
+    }
+    if (!state.folderUri) {
+        return undefined;
+    }
+    const isolation = state.isolationMode === "worktree" ? (branch ? {
+        kind: "worktree",
+        branch
+    } : undefined) : state.isolationMode === "workspace" ? {
+        kind: "folder"
+    } : {
+        kind: "default"
+    };
+    return isolation ? {
+        kind: "workspace",
+        folderUri: state.folderUri,
+        providerId: state.providerId,
+        sessionTypeId: state.sessionTypeId,
+        isolation
+    } : undefined;
+}
+
+export { AutomationDialogService };

package/vscode/src/vs/sessions/contrib/automations/browser/automationInputCompletions.d.ts

@@ -0,0 +1,33 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { ICodeEditorService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service";
+import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { CompletionItem } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IChatInputCompletionItem } 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 { AgentHostInputCompletionsBase } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/agentHostInputCompletionsBase";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+export declare class AutomationInputCompletions extends AgentHostInputCompletionsBase<void, string> {
+    private readonly editor;
+    private readonly sessionsManagementService;
+    private readonly logService;
+    private readonly registration;
+    private readonly restoreRequest;
+    private readonly restoreScheduler;
+    private references;
+    private triggerCharacters;
+    constructor(editor: ICodeEditor, languageFeaturesService: ILanguageFeaturesService, chatSessionsService: IChatSessionsService, sessionsManagementService: ISessionsManagementService, codeEditorService: ICodeEditorService, logService: ILogService);
+    private registerForScheme;
+    protected _resolveContext(model: ITextModel, scheme: string): {
+        sessionResource: URI;
+        context: void;
+    } | undefined;
+    protected _buildItem(position: Position, item: IChatInputCompletionItem): CompletionItem | undefined;
+    acceptCompletion(range: Range, text: string): void;
+    private restorePersistedSkillReferences;
+    private updateDecorations;
+}