@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/contrib/sessionComparison/browser/sessionComparisonGridController.js

@@ -0,0 +1,190 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { ISessionsPartService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { SessionComparisonParticipantRole } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionComparison';
+import { ISessionComparisonService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionComparison.service';
+import { HIDE_INACTIVE_COMPARISON_INPUTS_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessionComparison/common/sessionComparison';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const HIDE_INACTIVE_COMPARISON_INPUTS_CLASS = "session-comparison-hide-inactive-inputs";
+const COMPARISON_GRID_ACTIVE_CLASS = "session-comparison-grid-active";
+let SessionComparisonGridController = class SessionComparisonGridController extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessionComparisonGridController";
+    }
+    constructor(
+        sessionsPartService,
+        sessionsService,
+        comparisonService,
+        layoutService,
+        configurationService,
+        accessibilityService
+    ) {
+        super();
+        this.sessionsService = sessionsService;
+        this.comparisonService = comparisonService;
+        this.layoutService = layoutService;
+        this._comparisonGridActive = false;
+        this._keepSidePaneHidden = false;
+        this._partsHiddenByController = ( new Set());
+        const hideInactiveInputs = observableFromEvent(this, Event.filter(
+            configurationService.onDidChangeConfiguration,
+            event => event.affectsConfiguration(HIDE_INACTIVE_COMPARISON_INPUTS_SETTING)
+        ), () => configurationService.getValue(HIDE_INACTIVE_COMPARISON_INPUTS_SETTING));
+        const screenReaderOptimized = observableFromEvent(
+            this,
+            accessibilityService.onDidChangeScreenReaderOptimized,
+            () => accessibilityService.isScreenReaderOptimized()
+        );
+        this._register(autorun(reader => {
+            const visibleSessions = this.sessionsService.visibleSessions.read(reader);
+            const activeSession = this.sessionsService.activeSession.read(reader);
+            const comparisons = this.comparisonService.comparisons.read(reader);
+            this._comparisonGridActive = this._isComparisonGrid(visibleSessions, comparisons);
+            this.layoutService.mainContainer.classList.toggle(COMPARISON_GRID_ACTIVE_CLASS, this._comparisonGridActive);
+            this.layoutService.mainContainer.classList.toggle(
+                HIDE_INACTIVE_COMPARISON_INPUTS_CLASS,
+                hideInactiveInputs.read(reader) && !screenReaderOptimized.read(reader) && visibleSessions.length > 2 && this._isAttemptComparisonGrid(visibleSessions, comparisons)
+            );
+            if (!this._comparisonGridActive && this._isolatedJudgeSessionId && (visibleSessions.length !== 1 || visibleSessions[0]?.sessionId !== this._isolatedJudgeSessionId || activeSession?.sessionId !== this._isolatedJudgeSessionId)) {
+                this._isolatedJudgeSessionId = undefined;
+            }
+            const keepSidePaneHidden = this._comparisonGridActive || this._isolatedJudgeSessionId !== undefined;
+            const activeJudgeSessionId = this._getJudgeSessionId(activeSession, visibleSessions, comparisons);
+            if (activeJudgeSessionId) {
+                this._scheduleJudgeIsolation(activeJudgeSessionId);
+            }
+            this._setSidePaneSuppressed(keepSidePaneHidden);
+        }));
+        this._register(this.layoutService.onDidChangePartVisibility(event => {
+            if (event.visible && this._keepSidePaneHidden && (event.partId === Parts.EDITOR_PART || event.partId === Parts.AUXILIARYBAR_PART)) {
+                this._partsHiddenByController.delete(event.partId);
+            }
+        }));
+        this._register(
+            sessionsPartService.onDidFocusSession(sessionId => this._onDidFocusSession(sessionId))
+        );
+        this._register(toDisposable(() => {
+            this._setSidePaneSuppressed(false);
+            this.layoutService.mainContainer.classList.remove(HIDE_INACTIVE_COMPARISON_INPUTS_CLASS, COMPARISON_GRID_ACTIVE_CLASS);
+        }));
+    }
+    _onDidFocusSession(sessionId) {
+        if (sessionId === undefined) {
+            return;
+        }
+        const visibleSessions = this.sessionsService.visibleSessions.get();
+        const focusedSession = visibleSessions.find(session => session?.sessionId === sessionId);
+        if (this._getJudgeSessionId(focusedSession, visibleSessions, this.comparisonService.comparisons.get()) !== sessionId) {
+            return;
+        }
+        this._isolateJudge(sessionId);
+    }
+    _scheduleJudgeIsolation(sessionId) {
+        if (this._pendingJudgeIsolationSessionId === sessionId) {
+            return;
+        }
+        this._pendingJudgeIsolationSessionId = sessionId;
+        queueMicrotask(() => {
+            if (this._pendingJudgeIsolationSessionId !== sessionId) {
+                return;
+            }
+            this._pendingJudgeIsolationSessionId = undefined;
+            this._isolateJudge(sessionId);
+        });
+    }
+    _isolateJudge(sessionId) {
+        const visibleSessions = this.sessionsService.visibleSessions.get();
+        const judgeSession = visibleSessions.find(session => session?.sessionId === sessionId);
+        if (!judgeSession || this._getJudgeSessionId(judgeSession, visibleSessions, this.comparisonService.comparisons.get()) !== sessionId) {
+            return;
+        }
+        this._isolatedJudgeSessionId = sessionId;
+        for (const session of visibleSessions) {
+            if (session?.sessionId !== sessionId) {
+                this.sessionsService.closeSession(session);
+            }
+        }
+        this.sessionsService.showSession(judgeSession.resource);
+        this._setSidePaneSuppressed(true);
+    }
+    _isComparisonGrid(visibleSessions, comparisons) {
+        return this._getComparisonForVisibleSessions(visibleSessions, comparisons) !== undefined;
+    }
+    _isAttemptComparisonGrid(visibleSessions, comparisons) {
+        const comparison = this._getComparisonForVisibleSessions(visibleSessions, comparisons);
+        return !!comparison && visibleSessions.every(session => ( comparison.participants.some(
+            participant => participant.role === SessionComparisonParticipantRole.Attempt && participant.sessionResource && isEqual(participant.sessionResource, session.resource)
+        )));
+    }
+    _getJudgeSessionId(session, visibleSessions, comparisons) {
+        if (!session) {
+            return undefined;
+        }
+        const comparison = this._getComparisonForVisibleSessions(visibleSessions, comparisons);
+        const participant = comparison?.participants.find(
+            candidate => candidate.sessionResource && isEqual(candidate.sessionResource, session.resource)
+        );
+        return participant?.role === SessionComparisonParticipantRole.Judge ? session.sessionId : undefined;
+    }
+    _getComparisonForVisibleSessions(visibleSessions, comparisons) {
+        if (visibleSessions.length <= 1 || ( visibleSessions.some(session => !session))) {
+            return undefined;
+        }
+        const firstSession = visibleSessions[0];
+        const comparison = comparisons.find(candidate => candidate.archivedAt === undefined && ( candidate.participants.some(
+            participant => participant.sessionResource && isEqual(participant.sessionResource, firstSession.resource)
+        )));
+        return comparison && visibleSessions.every(session => ( comparison.participants.some(
+            participant => participant.sessionResource && isEqual(participant.sessionResource, session.resource)
+        ))) ? comparison : undefined;
+    }
+    _setSidePaneSuppressed(suppressed) {
+        if (this._keepSidePaneHidden === suppressed) {
+            return;
+        }
+        this._keepSidePaneHidden = suppressed;
+        if (suppressed) {
+            this._hideSidePane();
+        } else {
+            this._restoreSidePane();
+        }
+    }
+    _hideSidePane() {
+        const suppression = this.layoutService.suppressEditorPartAutoVisibility();
+        try {
+            if (this.layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+                this._partsHiddenByController.add(Parts.AUXILIARYBAR_PART);
+                this.layoutService.setPartHidden(true, Parts.AUXILIARYBAR_PART);
+            }
+            if (this.layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                this._partsHiddenByController.add(Parts.EDITOR_PART);
+                this.layoutService.setPartHidden(true, Parts.EDITOR_PART);
+            }
+        } finally {
+            suppression.dispose();
+        }
+    }
+    _restoreSidePane() {
+        for (const part of this._partsHiddenByController) {
+            if (!this.layoutService.isVisible(part, mainWindow)) {
+                this.layoutService.setPartHidden(false, part);
+            }
+        }
+        this._partsHiddenByController.clear();
+    }
+};
+SessionComparisonGridController = ( __decorate([( __param(0, ISessionsPartService)), ( __param(1, ISessionsService)), ( __param(2, ISessionComparisonService)), ( __param(3, IAgentWorkbenchLayoutService)), ( __param(4, IConfigurationService)), ( __param(5, IAccessibilityService))], SessionComparisonGridController));
+
+export { SessionComparisonGridController };

package/vscode/src/vs/sessions/contrib/sessionComparison/browser/sessionComparisonTool.d.ts

@@ -0,0 +1,31 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ISessionComparisonService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionComparison.service";
+export declare class ReadSessionComparisonTool implements IToolImpl {
+    private readonly comparisonService;
+    private readonly sessionsManagementService;
+    constructor(comparisonService: ISessionComparisonService, sessionsManagementService: ISessionsManagementService);
+    getToolData(): IToolData;
+    prepareToolInvocation(_context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, _token: CancellationToken): Promise<IToolResult>;
+}
+export declare class CompleteSessionComparisonTool implements IToolImpl {
+    private readonly comparisonService;
+    constructor(comparisonService: ISessionComparisonService);
+    getToolData(): IToolData;
+    prepareToolInvocation(_context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, _token: CancellationToken): Promise<IToolResult>;
+}
+export declare class SessionComparisonToolContribution extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "sessions.contrib.sessionComparisonTool";
+    private readonly _toolRegistrations;
+    private _toolsRegistered;
+    constructor(toolsService: ILanguageModelToolsService, instantiationService: IInstantiationService, comparisonService: ISessionComparisonService, configurationService: IConfigurationService);
+    private _registerComparisonTools;
+}