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

package/vscode/src/vs/sessions/services/sessions/browser/sessionsRecencyHistory.d.ts

@@ -1,42 +1,39 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IObservable, ITransaction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
-/** A single recently-opened entry: a chat within a session, or a session when no specific chat applies. */
-export interface IRecencyEntry {
+export type SessionRecencyEntry = {
+    readonly kind: "session";
     readonly sessionResource: URI;
     readonly chatResource: URI | undefined;
-}
+} | {
+    readonly kind: "newSession";
+} | {
+    readonly kind: "customView";
+    readonly id: string;
+};
+export declare function getRecencyEntryKey(entry: SessionRecencyEntry): string;
 /**
- * The single source of truth for "recently opened" ordering across the sessions
- * UI. Maintains an MRU-ordered list of `(session, chat)` entries (index 0 is the
- * most recently opened), deduplicated by the `(session, chat)` pair and capped at
- * {@link MAX_RECENCY_ENTRIES}. The list is persisted so recency survives reloads.
- *
- * Both the sessions picker (via
- * {@link ISessionsManagementService.getRecentlyOpenedSessions}) and the
- * Back/Forward navigation ({@link SessionsNavigation}) build on top of this.
+ * Shared MRU ordering for session navigation and the recent-sessions picker.
+ * Session/chat entries persist across reloads; singleton view entries are window-local.
  */
 export declare class SessionsRecencyHistory extends Disposable {
     private readonly _storageService;
     private readonly _logService;
     private static readonly STORAGE_KEY;
-    private static readonly MAX_RECENCY_ENTRIES;
+    private static readonly MAX_SESSION_ENTRIES;
     private _entries;
     private readonly _version;
     /** Bumped whenever {@link entries} changes, so observers can react. */
     get version(): IObservable<number>;
     /** The recency entries in MRU order (index 0 is the most recently opened). */
-    get entries(): readonly IRecencyEntry[];
+    get entries(): readonly SessionRecencyEntry[];
     constructor(_storageService: IStorageService, _logService: ILogService);
-    /**
-     * Record that the given session (optionally a specific chat within it) was
-     * explicitly opened, promoting it to the front of the MRU list.
-     */
-    markOpened(sessionResource: URI, chatResource: URI | undefined): void;
+    /** Promote the opened destination to the front, keeping only its most recent occurrence. */
+    markOpened(entry: SessionRecencyEntry, tx?: ITransaction): void;
     /** Remove every entry matching the given predicate. */
-    remove(predicate: (entry: IRecencyEntry) => boolean): void;
+    remove(predicate: (entry: SessionRecencyEntry) => boolean): void;
     private _bumpVersion;
     private _load;
     private _save;

package/vscode/src/vs/sessions/services/sessions/browser/sessionsRecencyHistory.js

@@ -1,19 +1,31 @@
 
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { getComparisonKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 
-function entryKey(sessionResource, chatResource) {
-    return `${( sessionResource.toString())}::${chatResource?.toString() ?? ""}`;
+function getRecencyEntryKey(entry) {
+    switch (entry.kind) {
+    case "session":
+        return JSON.stringify([
+            entry.kind,
+            getComparisonKey(entry.sessionResource),
+            entry.chatResource && getComparisonKey(entry.chatResource)
+        ]);
+    case "newSession":
+        return entry.kind;
+    case "customView":
+        return `${entry.kind}:${entry.id}`;
+    }
 }
 class SessionsRecencyHistory extends Disposable {
     static {
         this.STORAGE_KEY = "agentSessions.recencyHistory";
     }
     static {
-        this.MAX_RECENCY_ENTRIES = 50;
+        this.MAX_SESSION_ENTRIES = 50;
     }
     get version() {
         return this._version;
@@ -29,24 +41,22 @@ class SessionsRecencyHistory extends Disposable {
         this._version = observableValue(this, 0);
         this._entries = this._load();
     }
-    markOpened(sessionResource, chatResource) {
-        const key = entryKey(sessionResource, chatResource);
-        const existingIndex = this._entries.findIndex(e => entryKey(e.sessionResource, e.chatResource) === key);
+    markOpened(entry, tx) {
+        const key = getRecencyEntryKey(entry);
+        const existingIndex = this._entries.findIndex(e => getRecencyEntryKey(e) === key);
         if (existingIndex === 0) {
             return;
         }
         if (existingIndex > 0) {
             this._entries.splice(existingIndex, 1);
         }
-        this._entries.unshift({
-            sessionResource,
-            chatResource
-        });
-        if (this._entries.length > SessionsRecencyHistory.MAX_RECENCY_ENTRIES) {
-            this._entries.length = SessionsRecencyHistory.MAX_RECENCY_ENTRIES;
-        }
+        this._entries.unshift(entry);
+        let sessionEntries = 0;
+        this._entries = this._entries.filter(
+            candidate => candidate.kind !== "session" || ++sessionEntries <= SessionsRecencyHistory.MAX_SESSION_ENTRIES
+        );
         this._save();
-        this._bumpVersion();
+        this._bumpVersion(tx);
     }
     remove(predicate) {
         const next = this._entries.filter(e => !predicate(e));
@@ -57,8 +67,8 @@ class SessionsRecencyHistory extends Disposable {
         this._save();
         this._bumpVersion();
     }
-    _bumpVersion() {
-        this._version.set(this._version.get() + 1, undefined);
+    _bumpVersion(tx) {
+        this._version.set(this._version.get() + 1, tx);
     }
     _load() {
         const raw = this._storageService.get(SessionsRecencyHistory.STORAGE_KEY, StorageScope.WORKSPACE);
@@ -71,6 +81,7 @@ class SessionsRecencyHistory extends Disposable {
                 return [];
             }
             return parsed.filter(e => e && typeof e.session === "string").map(e => ({
+                kind: "session",
                 sessionResource: ( URI.parse(e.session)),
                 chatResource: e.chat ? ( URI.parse(e.chat)) : undefined
             }));
@@ -83,14 +94,14 @@ class SessionsRecencyHistory extends Disposable {
         }
     }
     _save() {
-        if (this._entries.length === 0) {
-            this._storageService.remove(SessionsRecencyHistory.STORAGE_KEY, StorageScope.WORKSPACE);
-            return;
-        }
-        const serialized = this._entries.map(e => ({
+        const serialized = this._entries.filter(e => e.kind === "session").map(e => ({
             session: ( e.sessionResource.toString()),
             chat: e.chatResource?.toString()
         }));
+        if (serialized.length === 0) {
+            this._storageService.remove(SessionsRecencyHistory.STORAGE_KEY, StorageScope.WORKSPACE);
+            return;
+        }
         this._storageService.store(
             SessionsRecencyHistory.STORAGE_KEY,
             JSON.stringify(serialized),
@@ -100,4 +111,4 @@ class SessionsRecencyHistory extends Disposable {
     }
 }
 
-export { SessionsRecencyHistory };
+export { SessionsRecencyHistory, getRecencyEntryKey };

package/vscode/src/vs/sessions/services/sessions/browser/sessionsService.d.ts

@@ -19,7 +19,10 @@ import { ICustomViewService } from "@codingame/monaco-vscode-api/vscode/vs/sessi
 import { ISessionChangesStatsCache } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionChangesStatsCache.service";
 import { SessionOpenSource } from "./sessionOpenTelemetryService.js";
 import { ISessionOpenTelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionOpenTelemetryService.service";
+import { Direction } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/grid/grid";
 import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+export type SessionGridDirection = "left" | "right" | "up" | "down";
+export declare function toSessionGridDirection(direction: Direction): SessionGridDirection;
 export interface ISessionNavigationRequest {
     /** The caller's token, so deferred handoffs can recognize their own navigation. */
     readonly token: CancellationToken;
@@ -43,6 +46,8 @@ export interface IOpenNewSessionOptions extends ICreateNewSessionOptions {
      * of the active session in the grid instead of replacing it in place.
      */
     readonly toSide?: boolean;
+    /** Require the created draft to start in a Dev Container rather than falling back to host execution. */
+    readonly requireDevContainer?: boolean;
 }
 /**
  * Result of {@link ISessionsService.openNewSession}. `session` holds the
@@ -69,6 +74,10 @@ export interface IOpenSessionOptions {
     readonly preserveFocus?: boolean;
     readonly source?: SessionOpenSource;
     readonly restoreOnlySideOrToolChat?: boolean;
+    readonly forceMainChat?: boolean;
+}
+export interface IOpenSessionsOptions extends IOpenSessionOptions {
+    readonly activate?: "first" | "last" | false;
 }
 export declare class SessionsService extends Disposable implements ISessionsService {
     private readonly storageService;
@@ -89,6 +98,7 @@ export declare class SessionsService extends Disposable implements ISessionsServ
     readonly onDidToggleSessionStickiness: Event<IToggleSessionStickinessEvent>;
     /** Owns the active/sticky/transient visibility model and the {@link IActiveSession} wrappers. */
     private readonly _visibility;
+    private readonly _gridRequest;
     readonly visibleSessions: IObservable<readonly (IActiveSession | undefined)[]>;
     /** Remembers the single most recently closed chat or session for {@link reopenLastClosedItem}. */
     private readonly _closedItems;
@@ -109,8 +119,10 @@ export declare class SessionsService extends Disposable implements ISessionsServ
      * to a session, or a new-session handoff with `cancelRestore`, cancels it.
      */
     private readonly _restoreCts;
+    private _restoringGridState;
     private readonly _sessionStates;
     private readonly _pendingRestoredChatResources;
+    private readonly _pendingExplicitChatOpens;
     private readonly _navigation;
     /**
      * The single source of truth for session recency (most-recently-opened
@@ -119,12 +131,8 @@ export declare class SessionsService extends Disposable implements ISessionsServ
      * top of it.
      */
     private readonly _recencyHistory;
-    /**
-     * Session id (or `undefined` for the new-session slot) that focus was last
-     * moved into in response to an active-session change. Tracks the active id
-     * so unrelated visibility updates don't re-focus and steal focus.
-     */
-    private _focusedActiveSessionId;
+    /** Tracks wrapper identity so same-ID replacements restore focus but unrelated visibility changes do not. */
+    private _focusedActiveSession;
     /** The in-flight foreground send's "keep newest chat active" follow. */
     private readonly _sendFollow;
     constructor(storageService: IStorageService, logService: ILogService, uriIdentityService: IUriIdentityService, contextKeyService: IContextKeyService, sessionsManagementService: ISessionsManagementService, sessionsProvidersService: ISessionsProvidersService, sessionsPartService: ISessionsPartService, customViewService: ICustomViewService, instantiationService: IInstantiationService, workspaceTrustRequestService: IWorkspaceTrustRequestService, workspaceTrustManagementService: IWorkspaceTrustManagementService, changesStatsCache: ISessionChangesStatsCache, sessionOpenTelemetryService: ISessionOpenTelemetryService);
@@ -174,7 +182,16 @@ export declare class SessionsService extends Disposable implements ISessionsServ
     canOpenSession(session: ISession): Promise<boolean>;
     openSessionToSide(session: ISession, options?: IOpenSessionOptions & {
         chatResource?: URI;
+        referenceSessionId?: string;
     }): Promise<void>;
+    private prepareGridSessions;
+    private areGridSessionsCurrent;
+    openSessionsAt(sessions: readonly ISession[], referenceSessionId: string | undefined, direction: SessionGridDirection, options?: IOpenSessionsOptions): Promise<void>;
+    openSessionsInGrid(sessions: readonly ISession[]): Promise<void>;
+    arrangeSessions(): void;
+    focusSessionInDirection(session: IActiveSession | undefined, direction: Direction): void;
+    moveSessionInDirection(session: IActiveSession | undefined, direction: Direction): void;
+    resizeSession(session: IActiveSession | undefined, direction: Direction): void;
     /**
      * Opens a chat to the side of its session view, redirecting a superseded
      * resource first so a migrating session opens its adopted twin to the side
@@ -183,7 +200,9 @@ export declare class SessionsService extends Disposable implements ISessionsServ
      */
     openChatToSide(session: ISession, chatResource: URI, options?: {
         preserveFocus?: boolean;
+        referenceChatResource?: URI;
     }): Promise<void>;
+    private _showChatToSide;
     /**
      * Redirects a superseded session to its authoritative facade before it is
      * shown (mirrors `openSession`'s URI resolution). Provider-neutral: it asks
@@ -200,13 +219,13 @@ export declare class SessionsService extends Disposable implements ISessionsServ
     private _openNewSession;
     /** Open or move beside the active session when requested, keeping a single empty slot. */
     private _activateOrInsert;
-    openQuickChat(options?: ICreateNewSessionOptions): IActiveSession | undefined;
+    openQuickChat(options?: ICreateNewSessionOptions, preserveNavigation?: boolean): IActiveSession | undefined;
     private _openQuickChat;
     openNewChatInSession(session: ISession, options?: ICreateNewChatInSessionOptions): Promise<void>;
     setActive(session: IActiveSession | undefined): void;
     submitNewSessionInput(): Promise<boolean>;
     toggleSessionStickiness(session: ISession): void;
-    insertAt(session: ISession | undefined, targetSessionId: string, side: "left" | "right", activate?: boolean): void;
+    insertAt(session: ISession | undefined, targetSessionId: string | undefined, side: SessionGridDirection, activate?: boolean): void;
     closeSession(session: ISession | undefined): void;
     closeAllSessions(): void;
     private _restoreInitialChat;
@@ -221,6 +240,7 @@ export declare class SessionsService extends Disposable implements ISessionsServ
     private _waitForSessionToLoad;
     private _loadSessionStates;
     private _saveSessionStates;
+    private loadGridState;
     private _snapshotVisibleSessionStates;
     /**
      * The persisted visible sessions, ordered left-to-right by their stored