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

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsMouseNavigation.d.ts

@@ -0,0 +1,13 @@
+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 { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+export declare class SessionsMouseNavigationContribution extends Disposable implements IWorkbenchContribution {
+    private readonly configurationService;
+    private readonly layoutService;
+    private readonly sessionsService;
+    static readonly ID = "workbench.contrib.sessionsMouseNavigation";
+    constructor(configurationService: IConfigurationService, layoutService: IWorkbenchLayoutService, sessionsService: ISessionsService);
+    private handleMouseNavigation;
+}

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsMouseNavigation.js

@@ -0,0 +1,69 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { addDisposableListener, EventType } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } 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 { MOUSE_BACK_FORWARD_NAVIGATION_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/history/common/history';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+
+let SessionsMouseNavigationContribution = class SessionsMouseNavigationContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessionsMouseNavigation";
+    }
+    constructor(configurationService, layoutService, sessionsService) {
+        super();
+        this.configurationService = configurationService;
+        this.layoutService = layoutService;
+        this.sessionsService = sessionsService;
+        const mouseNavigationListeners = this._register(( new DisposableStore()));
+        this._register(Event.runAndSubscribe(this.layoutService.onDidAddContainer, (
+            {
+                container,
+                disposables
+            }
+        ) => {
+            const eventDisposables = disposables.add(( new DisposableStore()));
+            eventDisposables.add(addDisposableListener(
+                container,
+                EventType.MOUSE_DOWN,
+                event => this.handleMouseNavigation(event, true),
+                true
+            ));
+            eventDisposables.add(addDisposableListener(
+                container,
+                EventType.MOUSE_UP,
+                event => this.handleMouseNavigation(event, false),
+                true
+            ));
+            mouseNavigationListeners.add(eventDisposables);
+        }, {
+            container: this.layoutService.mainContainer,
+            disposables: this._store
+        }));
+    }
+    handleMouseNavigation(event, isMouseDown) {
+        if (!this.configurationService.getValue(MOUSE_BACK_FORWARD_NAVIGATION_SETTING) || this.layoutService.hasFocus(Parts.EDITOR_PART)) {
+            return;
+        }
+        if (event.button !== 3 && event.button !== 4) {
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        event.stopImmediatePropagation();
+        if (!isMouseDown) {
+            return;
+        }
+        if (event.button === 3) {
+            void this.sessionsService.openPreviousSession();
+        } else {
+            void this.sessionsService.openNextSession();
+        }
+    }
+};
+SessionsMouseNavigationContribution = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IWorkbenchLayoutService)), ( __param(2, ISessionsService))], SessionsMouseNavigationContribution));
+
+export { SessionsMouseNavigationContribution };

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsPicker.d.ts

@@ -0,0 +1,10 @@
+import { IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+export interface ISessionsPickerGroups {
+    readonly needsInput: readonly ISession[];
+    readonly unread: readonly ISession[];
+    readonly recent: readonly ISession[];
+    readonly other: readonly ISession[];
+}
+/** Groups sessions by picker priority while preserving their existing order. */
+export declare function groupSessionsForPicker(recentSessions: readonly ISession[], otherSessions: readonly ISession[], reader?: IReader): ISessionsPickerGroups;

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsPicker.js

@@ -0,0 +1,33 @@
+
+import { SessionStatus, isActiveSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+
+function groupSessionsForPicker(recentSessions, otherSessions, reader) {
+    const needsInput = [];
+    const unread = [];
+    const recent = [];
+    const other = [];
+    const groupSession = (session, remaining) => {
+        const status = session.status.read(reader);
+        if (session.isArchived.read(reader)) {
+            return;
+        }
+        else if (status === SessionStatus.NeedsInput) {
+            needsInput.push(session);
+        }
+        else if (!isActiveSessionStatus(status) && !session.isRead.read(reader)) {
+            unread.push(session);
+        }
+        else {
+            remaining.push(session);
+        }
+    };
+    for (const session of recentSessions) {
+        groupSession(session, recent);
+    }
+    for (const session of otherSessions) {
+        groupSession(session, other);
+    }
+    return { needsInput, unread, recent, other };
+}
+
+export { groupSessionsForPicker };

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsTelemetry.contribution.d.ts

@@ -0,0 +1,126 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.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 { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ISearchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service";
+import { IAgentFeedbackService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/agentFeedback/browser/agentFeedbackService.service";
+import { ISessionsTasksService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionsTasksService.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { ISessionsPartService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service";
+import { ISessionsWindowUsageService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsWindowUsageService.service";
+/**
+ * Listens to lifecycle events from {@link ISessionsManagementService} and
+ * emits telemetry for them. The per-event classifications declared below are
+ * intentionally flat (not composed via intersections) so that the telemetry
+ * classification scanner can resolve every event from a single literal type.
+ * The internal `getXxxFields` getters simply assemble the payload that is then
+ * handed to the appropriate `publicLog2<...>` call site.
+ */
+export declare class SessionsTelemetryContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _sessionsManagementService;
+    private readonly _sessionsService;
+    private readonly _telemetryService;
+    private readonly _uriIdentityService;
+    private readonly _storageService;
+    private readonly _searchService;
+    private readonly _configurationService;
+    private readonly _sessionsTasksService;
+    static readonly ID = "workbench.contrib.sessionsTelemetry";
+    /** Final workspace file counts, keyed by session id (so subsequent log calls for the same session are instant). */
+    private readonly _workspaceFileCountCache;
+    /** Pending workspace file-count fetches, keyed by workspace URI so a prewarm started before a session-id assignment can be picked up after. */
+    private readonly _workspaceFileCountInFlight;
+    /** Persists per-session lifecycle counters for the `agents/sessionSummary` event. */
+    private readonly _lifecycleTracker;
+    /** Counts characters the user manually types into session workspace folders from this window. */
+    private readonly _typedCharactersTracker;
+    /** Listener per provider that waits for the provider's first batch of sessions so we can run a one-time reconciliation against tracked entries. */
+    private readonly _providerReconcileListeners;
+    constructor(_sessionsManagementService: ISessionsManagementService, _sessionsService: ISessionsService, _telemetryService: ITelemetryService, _uriIdentityService: IUriIdentityService, _storageService: IStorageService, _searchService: ISearchService, _configurationService: IConfigurationService, commandService: ICommandService, agentFeedbackService: IAgentFeedbackService, sessionsPartService: ISessionsPartService, sessionsProvidersService: ISessionsProvidersService, _sessionsTasksService: ISessionsTasksService, modelService: IModelService, sessionsWindowUsageService: ISessionsWindowUsageService);
+    /**
+     * Resolves the session a session-scoped command was invoked on. The first
+     * argument is expected to be either a session resource {@link URI} or a
+     * `{ resource: URI }` shape (e.g. a `ChatSessionItem`). Returns `undefined`
+     * if the argument is not a recognized session reference.
+     */
+    private _getSessionFromCommandArgs;
+    private _logRequestSent;
+    private _logSessionArchived;
+    private _logSessionUnarchived;
+    private _logSessionDeleted;
+    private _logChatDeleted;
+    private _logChatRenamed;
+    private _logSessionRenamed;
+    private _logSessionStickinessToggled;
+    private _logSessionMaximizeToggled;
+    private _logCreatePullRequest;
+    private _logCreateDraftPullRequest;
+    private _logUpdatePullRequest;
+    private _logMergePullRequest;
+    private _logCheckoutPullRequest;
+    private _logInitializeRepository;
+    private _logCommit;
+    private _logCommitAndSync;
+    private _logSessionRestored;
+    private _logFixCIChecks;
+    private _logFeedbackAdded;
+    private _logFeedbackConverted;
+    private _logFeedbackReplyAdded;
+    private _logFeedbackSubmitted;
+    /**
+     * Reacts to the session list changing across all providers and emits a
+     * `agents/sessionSummary` event for tracked sessions that the user
+     * finished (archived or deleted) in a different client. Local archive /
+     * delete are handled directly by {@link _logSessionArchived} /
+     * {@link _logSessionDeleted}; the deferred timer here gives those handlers
+     * a chance to claim the tracked entry first so the `doneReason` is
+     * reported as `archived` / `deleted` rather than `archivedRemotely` /
+     * `deletedRemotely`.
+     */
+    private _onDidChangeSessions;
+    /**
+     * Schedules a one-time reconciliation of tracked entries for `provider`.
+     * Reconciliation runs as soon as the provider reports at least one live
+     * session (its "loaded" signal). If the provider already has sessions at
+     * registration time, this runs synchronously; otherwise we wait on
+     * `onDidChangeSessions` and dispose the listener after the first run.
+     */
+    private _trackProviderForReconciliation;
+    /**
+     * Reconciles tracked entries for `provider` against its current sessions.
+     * For each tracked entry: finalizes as `deletedRemotely` when missing, or
+     * `archivedRemotely` when present and archived. Returns `true` once the
+     * provider has reported at least one session (so the caller can stop
+     * listening).
+     */
+    private _tryReconcileProvider;
+    private _fireSessionSummary;
+    private _logSessionSummary;
+    /**
+     * Attributes a reported batch to the session each entry was typed into and
+     * returns the entries that could not be attributed yet.
+     *
+     * An absent workspace does not mean the file is unrelated: session
+     * workspaces hydrate asynchronously, so those entries are handed back to be
+     * retried rather than dropped. A quick chat is workspace-less by product
+     * intent, so its typing is discarded instead of retried.
+     */
+    private _recordTypedCharacters;
+    private _getSessionActionPayload;
+    private _getSessionFields;
+    private _getSessionChangesFields;
+    private _getChatFields;
+    private _getWorkspaceFields;
+    private _getWorkspaceTopologyFields;
+    private _getOrFetchWorkspaceFileCount;
+    private _startWorkspaceFileCountFetch;
+    private _computeWorkspaceFileCount;
+    private _getRequestFields;
+    private _getAllSessionsFields;
+}