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

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessionsActions.js

@@ -0,0 +1,199 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { registerAction2, Action2 } 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 { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { SessionTypeContext, SessionProviderIdContext, IsNewChatSessionContext, SessionHasGitRepositoryContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { BranchPicker } from './branchPicker.js';
+import { COPILOT_PROVIDER_ID, CopilotCloudSessionType, CopilotChatSessionsProvider } from './copilotChatSessionsProvider.js';
+import { ScopedModePickerModelCache, ModePicker } from './modePicker.js';
+import { CopilotPermissionPickerDelegate, PermissionPicker } from './permissionPicker.js';
+import { SandboxPicker } from './sandboxPicker.js';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { CopilotCLISessionType } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/agentHost/browser/baseAgentHostSessionsProvider';
+import { ISessionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionContext.service';
+
+const IsActiveSessionCopilotCLI = ( ContextKeyExpr.equals(SessionTypeContext.key, CopilotCLISessionType.id));
+const IsActiveCopilotChatSessionProvider = ( ContextKeyExpr.equals(SessionProviderIdContext.key, COPILOT_PROVIDER_ID));
+const IsActiveSessionCopilotChatCLI = ( ContextKeyExpr.and(IsActiveSessionCopilotCLI, IsActiveCopilotChatSessionProvider));
+const IsActiveSessionCopilotChatCloud = ( ContextKeyExpr.and(( ContextKeyExpr.equals(SessionTypeContext.key, CopilotCloudSessionType.id)), IsActiveCopilotChatSessionProvider));
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.defaultCopilot.branchPicker",
+            title: ( localize2(4201, "Branch")),
+            f1: false,
+            menu: [{
+                id: Menus.NewSessionRepositoryConfig,
+                group: "navigation",
+                order: 2,
+                when: ( ContextKeyExpr.and(
+                    IsNewChatSessionContext,
+                    IsActiveSessionCopilotChatCLI,
+                    SessionHasGitRepositoryContext
+                ))
+            }]
+        });
+    }
+    async run() {}
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.defaultCopilot.sandboxPicker",
+            title: ( localize2(4202, "Sandbox")),
+            f1: false,
+            menu: [{
+                id: Menus.NewSessionRepositoryConfig,
+                group: "navigation",
+                order: 3,
+                when: ( ContextKeyExpr.and(
+                    IsNewChatSessionContext,
+                    IsActiveSessionCopilotChatCloud,
+                    ChatContextKeys.enabled
+                ))
+            }]
+        });
+    }
+    async run() {}
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.defaultCopilot.modePicker",
+            title: ( localize2(4203, "Mode")),
+            f1: false,
+            menu: [{
+                id: Menus.NewSessionConfig,
+                group: "navigation",
+                order: 0,
+                when: IsActiveSessionCopilotChatCLI
+            }]
+        });
+    }
+    async run() {}
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.defaultCopilot.permissionPicker",
+            title: ( localize2(4204, "Permissions")),
+            f1: false,
+            menu: [{
+                id: Menus.NewSessionControl,
+                group: "navigation",
+                order: 1,
+                when: IsActiveSessionCopilotChatCLI
+            }]
+        });
+    }
+    async run() {}
+});
+class PickerActionViewItem extends BaseActionViewItem {
+    constructor(picker, disposable) {
+        super(undefined, {
+            id: "",
+            label: "",
+            enabled: true,
+            class: undefined,
+            tooltip: "",
+            run: () => {}
+        });
+        this.picker = picker;
+        if (disposable) {
+            this._register(disposable);
+        }
+    }
+    render(container) {
+        this.picker.render(container);
+    }
+    dispose() {
+        this.picker.dispose();
+        super.dispose();
+    }
+}
+let CopilotPickerActionViewItemContribution = class CopilotPickerActionViewItemContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.copilotPickerActionViewItems";
+    }
+    constructor(actionViewItemService, sessionsProvidersService) {
+        super();
+        const modePickerModels = this._register(( new ScopedModePickerModelCache(
+            session => sessionsProvidersService.getProvider(session.providerId) instanceof CopilotChatSessionsProvider
+        )));
+        this._register(actionViewItemService.register(
+            Menus.NewSessionRepositoryConfig,
+            "sessions.defaultCopilot.branchPicker",
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                const picker = scopedInstantiationService.createInstance(BranchPicker, session);
+                return ( new PickerActionViewItem(picker));
+            }
+        ));
+        this._register(actionViewItemService.register(
+            Menus.NewSessionRepositoryConfig,
+            "sessions.defaultCopilot.sandboxPicker",
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                const picker = scopedInstantiationService.createInstance(SandboxPicker, session);
+                return ( new PickerActionViewItem(picker));
+            }
+        ));
+        this._register(actionViewItemService.register(
+            Menus.NewSessionConfig,
+            "sessions.defaultCopilot.modePicker",
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                const disposableStore = ( new DisposableStore());
+                const modePickerModel = disposableStore.add(modePickerModels.acquire(session, scopedInstantiationService));
+                const picker = scopedInstantiationService.createInstance(ModePicker, modePickerModel.model, session);
+                disposableStore.add(picker.onDidSelect(mode => {
+                    const scopedSession = session.get();
+                    if (!scopedSession) {
+                        return;
+                    }
+                    const provider = sessionsProvidersService.getProvider(scopedSession.providerId);
+                    if (provider instanceof CopilotChatSessionsProvider) {
+                        provider.getSession(scopedSession.sessionId)?.setMode(mode);
+                    }
+                }));
+                return ( new PickerActionViewItem(picker, disposableStore));
+            }
+        ));
+        if (!isWeb) {
+            this._register(actionViewItemService.register(
+                Menus.NewSessionControl,
+                "sessions.defaultCopilot.permissionPicker",
+                (_action, _options, scopedInstantiationService) => {
+                    const {
+                        session
+                    } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                    const delegate = scopedInstantiationService.createInstance(CopilotPermissionPickerDelegate, session);
+                    const picker = scopedInstantiationService.createInstance(PermissionPicker, delegate);
+                    return ( new PickerActionViewItem(picker, delegate));
+                }
+            ));
+        }
+    }
+};
+CopilotPickerActionViewItemContribution = ( __decorate([( __param(0, IActionViewItemService)), ( __param(1, ISessionsProvidersService))], CopilotPickerActionViewItemContribution));
+registerWorkbenchContribution2(
+    CopilotPickerActionViewItemContribution.ID,
+    CopilotPickerActionViewItemContribution,
+    WorkbenchPhase.AfterRestored
+);
+
+export { PickerActionViewItem };

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessionsChangesets.d.ts

@@ -0,0 +1,104 @@
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IChatSessionFileChange2 } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChat, ISessionChangeset, ISessionChangesetOperation, ISessionChangesetOperationTarget, ISessionFileChange, ISessionWorkspace } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+interface IChangesetResolver {
+    resolve(firstCheckpointRef: string, lastCheckpointRef: string | undefined): Promise<IChatSessionFileChange2[] | undefined>;
+}
+export declare function createChangesets(sessionType: string, workspaceObs: IObservable<ISessionWorkspace | undefined>, chatsObs: IObservable<readonly IChat[]>, instantiationService: IInstantiationService): IObservable<readonly ISessionChangeset[]>;
+/**
+ * Common base for {@link ISessionChangeset} implementations.
+ *
+ * Changesets operate at the session level and derive everything they need
+ * from the session's chats list (checkpoints, archived state, last-turn
+ * end time). Subclasses that need session-level metadata not carried on
+ * `IChat` (e.g. workspace / git repository info) take those as additional
+ * constructor parameters.
+ */
+declare abstract class AbstractChangeset implements ISessionChangeset {
+    protected readonly _chats: IObservable<readonly IChat[]>;
+    abstract readonly id: string;
+    abstract readonly label: string;
+    abstract readonly description?: string;
+    abstract readonly isEnabled: IObservable<boolean>;
+    abstract readonly isDefault: IObservable<boolean>;
+    abstract readonly isLoadingChanges: IObservable<boolean>;
+    abstract readonly changes: IObservable<readonly ISessionFileChange[]>;
+    abstract readonly originalCheckpointRef: IObservable<string | undefined>;
+    abstract readonly modifiedCheckpointRef: IObservable<string | undefined>;
+    readonly operations: IObservable<readonly ISessionChangesetOperation[]>;
+    constructor(_chats: IObservable<readonly IChat[]>);
+    invokeOperation(_operationId: string, _target?: ISessionChangesetOperationTarget): Promise<void>;
+}
+/**
+ * Diff between a branch and its base (e.g. `main...feature`). Used for
+ * PR-style review and "what changed on this branch" views. Expected to be
+ * semi-static — refresh on new commits to either ref.
+ */
+export declare class BranchChangesChangeset extends AbstractChangeset {
+    static readonly ID = "branch";
+    readonly id = "branch";
+    readonly label: string;
+    readonly description: string | undefined;
+    readonly category: string;
+    readonly isEnabled: IObservable<boolean>;
+    readonly isDefault: IObservable<boolean>;
+    readonly isLoadingChanges: IObservable<boolean>;
+    readonly changes: IObservable<readonly ISessionFileChange[]>;
+    readonly originalCheckpointRef: IObservable<string | undefined>;
+    readonly modifiedCheckpointRef: IObservable<string | undefined>;
+    constructor(workspaceObs: IObservable<ISessionWorkspace | undefined>, chatsObs: IObservable<readonly IChat[]>);
+}
+/**
+ * Uncommitted changes in a session's working tree (index + working tree +
+ * untracked + merge).
+ */
+export declare class UncommittedChangesChangeset extends AbstractChangeset {
+    static readonly ID = "uncommittedChanges";
+    readonly id = "uncommittedChanges";
+    readonly label: string;
+    readonly description: string;
+    readonly category: string;
+    readonly isEnabled: IObservable<boolean>;
+    readonly isDefault: IObservable<boolean>;
+    readonly isLoadingChanges: IObservable<boolean>;
+    readonly changes: IObservable<readonly ISessionFileChange[]>;
+    readonly originalCheckpointRef: IObservable<string>;
+    readonly modifiedCheckpointRef: IObservable<string | undefined>;
+    constructor(workspaceObs: IObservable<ISessionWorkspace | undefined>, chatsObs: IObservable<readonly IChat[]>, changesetResolver: IChangesetResolver);
+}
+/**
+ * Aggregate of every file the session has touched.
+ */
+export declare class AllChangesChangeset extends AbstractChangeset {
+    static readonly ID = "allChanges";
+    readonly id = "allChanges";
+    readonly label: string;
+    readonly description: string;
+    readonly category: string;
+    readonly isEnabled: IObservable<boolean>;
+    readonly isDefault: IObservable<boolean>;
+    readonly isLoadingChanges: IObservable<boolean>;
+    readonly changes: IObservable<readonly ISessionFileChange[]>;
+    readonly originalCheckpointRef: IObservable<string | undefined>;
+    readonly modifiedCheckpointRef: IObservable<string | undefined>;
+    constructor(chatsObs: IObservable<readonly IChat[]>, changesetResolver: IChangesetResolver);
+}
+/**
+ * Files touched by the most recent agent turn.
+ */
+export declare class LastTurnChangesChangeset extends AbstractChangeset {
+    static readonly ID = "lastTurnChanges";
+    readonly id = "lastTurnChanges";
+    readonly label: string;
+    readonly description: string;
+    readonly category: string;
+    readonly isEnabled: IObservable<boolean>;
+    readonly isDefault: IObservable<boolean>;
+    readonly isLoadingChanges: IObservable<boolean>;
+    readonly changes: IObservable<readonly ISessionFileChange[]>;
+    readonly originalCheckpointRef: IObservable<string | undefined>;
+    readonly modifiedCheckpointRef: IObservable<string | undefined>;
+    constructor(chatsObs: IObservable<readonly IChat[]>, changesetResolver: IChangesetResolver);
+}
+export {};

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessionsChangesets.js

@@ -0,0 +1,301 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { IGitService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/git/common/gitService.service';
+import { gitHubInfoEqual, BRANCH_CHANGES_CHANGESET_ID, sessionFileChangesEqual } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { IGitHubService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/githubService.service';
+import { toPRContentUri } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/common/utils';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+import { derivedOpts, derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/promise';
+
+let GitRepositoryChangesetResolver = class GitRepositoryChangesetResolver {
+    constructor(workspace, _gitService) {
+        this._gitService = _gitService;
+        this._repositoryUriObs = derivedOpts({
+            equalsFn: isEqual
+        }, reader => {
+            const gitRepository = workspace.read(reader)?.folders[0].gitRepository;
+            return gitRepository?.workTreeUri ?? gitRepository?.uri;
+        });
+    }
+    async resolve(firstCheckpointRef, lastCheckpointRef) {
+        const repositoryUri = this._repositoryUriObs.get();
+        if (!repositoryUri) {
+            return [];
+        }
+        const repository = await this._gitService.openRepository(repositoryUri);
+        const ref = lastCheckpointRef ? `${firstCheckpointRef}..${lastCheckpointRef}` : firstCheckpointRef;
+        const changes = (await repository?.diffBetweenWithStats2(ref)) ?? [];
+        return toIChatSessionFileChange2(changes, firstCheckpointRef, lastCheckpointRef);
+    }
+};
+GitRepositoryChangesetResolver = ( __decorate([( __param(1, IGitService))], GitRepositoryChangesetResolver));
+let GitHubRepositoryChangesetResolver = class GitHubRepositoryChangesetResolver {
+    constructor(workspace, _gitHubService) {
+        this._gitHubService = _gitHubService;
+        this._gitHubInfoObs = derivedOpts({
+            equalsFn: gitHubInfoEqual
+        }, reader => {
+            const gitRepository = workspace.read(reader)?.folders[0].gitRepository;
+            return gitRepository?.gitHubInfo.read(reader);
+        });
+    }
+    async resolve(firstCheckpointRef, lastCheckpointRef) {
+        const gitHubInfo = this._gitHubInfoObs.get();
+        if (!gitHubInfo || !gitHubInfo.pullRequest?.number) {
+            return undefined;
+        }
+        const params = {
+            owner: gitHubInfo.owner,
+            repo: gitHubInfo.repo,
+            prNumber: gitHubInfo.pullRequest.number
+        };
+        const changes = await this._gitHubService.getChangedFiles(params.owner, params.repo, firstCheckpointRef, lastCheckpointRef);
+        return changes.map(change => {
+            const uri = toPRContentUri(change.filename, {
+                ...params,
+                commitSha: lastCheckpointRef,
+                status: change.status,
+                isBase: false
+            });
+            const originalUri = change.status !== "added" ? toPRContentUri(change.previous_filename || change.filename, {
+                ...params,
+                commitSha: firstCheckpointRef,
+                previousFileName: change.previous_filename,
+                status: change.status,
+                isBase: true
+            }) : undefined;
+            const modifiedUri = change.status !== "removed" ? uri : undefined;
+            return {
+                uri,
+                originalUri,
+                modifiedUri,
+                insertions: change.additions,
+                deletions: change.deletions
+            };
+        });
+    }
+};
+GitHubRepositoryChangesetResolver = ( __decorate([( __param(1, IGitHubService))], GitHubRepositoryChangesetResolver));
+function createChangesets(sessionType, workspaceObs, chatsObs, instantiationService) {
+    const changesetResolver = sessionType === AgentSessionProviders.Cloud ? instantiationService.createInstance(GitHubRepositoryChangesetResolver, workspaceObs) : instantiationService.createInstance(GitRepositoryChangesetResolver, workspaceObs);
+    const changesets = [( new BranchChangesChangeset(workspaceObs, chatsObs))];
+    if (sessionType !== AgentSessionProviders.Cloud) {
+        changesets.push(( new UncommittedChangesChangeset(workspaceObs, chatsObs, changesetResolver)));
+    }
+    changesets.push(( new AllChangesChangeset(chatsObs, changesetResolver)));
+    changesets.push(( new LastTurnChangesChangeset(chatsObs, changesetResolver)));
+    return constObservable(changesets);
+}
+class AbstractChangeset {
+    constructor(_chats) {
+        this._chats = _chats;
+        this.operations = constObservable([]);
+    }
+    async invokeOperation(_operationId, _target) {}
+}
+class BranchChangesChangeset extends AbstractChangeset {
+    static {
+        this.ID = BRANCH_CHANGES_CHANGESET_ID;
+    }
+    constructor(workspaceObs, chatsObs) {
+        super(chatsObs);
+        this.id = BranchChangesChangeset.ID;
+        this.label = ( localize(4205, "Branch Changes"));
+        this.category = ( localize(4206, "Changes"));
+        this.isLoadingChanges = constObservable(false);
+        this.modifiedCheckpointRef = constObservable(undefined);
+        const gitRepository = workspaceObs.get()?.folders[0].gitRepository;
+        const branchName = gitRepository?.branchName;
+        const baseBranchName = gitRepository?.baseBranchName;
+        this.description = branchName && baseBranchName ? `${branchName} → ${baseBranchName}` : branchName;
+        this.originalCheckpointRef = derived(reader => {
+            return chatsObs.read(reader)[0]?.checkpoints.read(reader)?.firstCheckpointRef;
+        });
+        const isArchivedObs = derived(reader => chatsObs.read(reader)[0]?.isArchived.read(reader) === true);
+        this.isDefault = derived(reader => !isArchivedObs.read(reader));
+        this.isEnabled = derived(reader => !isArchivedObs.read(reader));
+        this.changes = derived(reader => {
+            return chatsObs.read(reader)[0]?.changes.read(reader) ?? [];
+        });
+    }
+}
+class UncommittedChangesChangeset extends AbstractChangeset {
+    static {
+        this.ID = "uncommittedChanges";
+    }
+    constructor(workspaceObs, chatsObs, changesetResolver) {
+        super(chatsObs);
+        this.id = UncommittedChangesChangeset.ID;
+        this.label = ( localize(4207, "Uncommitted Changes"));
+        this.description = ( localize(4208, "Show uncommitted changes in this session"));
+        this.category = ( localize(4206, "Changes"));
+        this.isDefault = constObservable(false);
+        this.originalCheckpointRef = constObservable("HEAD");
+        this.modifiedCheckpointRef = constObservable(undefined);
+        this.isEnabled = derived(reader => chatsObs.read(reader)[0]?.isArchived.read(reader) !== true);
+        const uncommittedChangesCountObs = derived(reader => {
+            const gitRepository = workspaceObs.read(reader)?.folders[0].gitRepository;
+            return gitRepository?.uncommittedChanges ?? 0;
+        });
+        const changesPromiseObs = derived(reader => {
+            const originalCheckpointRef = this.originalCheckpointRef.read(reader);
+            const modifiedCheckpointRef = this.modifiedCheckpointRef.read(reader);
+            uncommittedChangesCountObs.read(reader);
+            const diffPromise = changesetResolver.resolve(originalCheckpointRef, modifiedCheckpointRef);
+            return ( new ObservablePromise(diffPromise)).resolvedValue;
+        });
+        this.isLoadingChanges = derived(reader => {
+            return changesPromiseObs.read(reader).read(reader) === undefined;
+        });
+        this.changes = derivedOpts({
+            equalsFn: sessionFileChangesEqual
+        }, reader => {
+            return changesPromiseObs.read(reader).read(reader) ?? [];
+        });
+    }
+}
+class AllChangesChangeset extends AbstractChangeset {
+    static {
+        this.ID = "allChanges";
+    }
+    constructor(chatsObs, changesetResolver) {
+        super(chatsObs);
+        this.id = AllChangesChangeset.ID;
+        this.label = ( localize(4209, "All Changes"));
+        this.description = ( localize(4210, "Show all changes made in this session"));
+        this.category = ( localize(4211, "Checkpoints"));
+        this.originalCheckpointRef = derived(reader => {
+            return chatsObs.read(reader)[0]?.checkpoints.read(reader)?.firstCheckpointRef;
+        });
+        this.modifiedCheckpointRef = derived(reader => {
+            const chats = chatsObs.read(reader);
+            if (chats.length === 0) {
+                return undefined;
+            }
+            if (chats.length === 1) {
+                return chats[0].checkpoints.read(reader)?.lastCheckpointRef;
+            }
+            const chatsSortedByLastTurnEnd = chats.toSorted((chatA, chatB) => {
+                const chatALastTurnEnd = chatA.lastTurnEnd.read(reader);
+                const chatBLastTurnEnd = chatB.lastTurnEnd.read(reader);
+                return sortDateDesc(chatALastTurnEnd, chatBLastTurnEnd);
+            });
+            return chatsSortedByLastTurnEnd[0].checkpoints.read(reader)?.lastCheckpointRef;
+        });
+        const changesPromiseObs = derived(reader => {
+            const originalCheckpointRef = this.originalCheckpointRef.read(reader);
+            const modifiedCheckpointRef = this.modifiedCheckpointRef.read(reader);
+            if (!originalCheckpointRef || !modifiedCheckpointRef) {
+                return constObservable([]);
+            }
+            const diffPromise = changesetResolver.resolve(originalCheckpointRef, modifiedCheckpointRef);
+            return ( new ObservablePromise(diffPromise)).resolvedValue;
+        });
+        this.isLoadingChanges = derived(reader => {
+            return changesPromiseObs.read(reader).read(reader) === undefined;
+        });
+        this.changes = derivedOpts({
+            equalsFn: sessionFileChangesEqual
+        }, reader => {
+            return changesPromiseObs.read(reader).read(reader) ?? [];
+        });
+        this.isDefault = derived(reader => chatsObs.read(reader)[0]?.isArchived.read(reader) === true);
+        this.isEnabled = derived(
+            reader => this.originalCheckpointRef.read(reader) !== undefined && this.modifiedCheckpointRef.read(reader) !== undefined
+        );
+    }
+}
+class LastTurnChangesChangeset extends AbstractChangeset {
+    static {
+        this.ID = "lastTurnChanges";
+    }
+    constructor(chatsObs, changesetResolver) {
+        super(chatsObs);
+        this.id = LastTurnChangesChangeset.ID;
+        this.label = ( localize(4212, "Last Turn Changes"));
+        this.description = ( localize(4213, "Show only changes made in the last turn"));
+        this.category = ( localize(4211, "Checkpoints"));
+        this.isDefault = constObservable(false);
+        this.modifiedCheckpointRef = derived(reader => {
+            const chats = chatsObs.read(reader);
+            if (chats.length === 0) {
+                return undefined;
+            }
+            if (chats.length === 1) {
+                return chats[0].checkpoints.read(reader)?.lastCheckpointRef;
+            }
+            const chatsSortedByLastTurnEnd = chats.toSorted((chatA, chatB) => {
+                const chatALastTurnEnd = chatA.lastTurnEnd.read(reader);
+                const chatBLastTurnEnd = chatB.lastTurnEnd.read(reader);
+                return sortDateDesc(chatALastTurnEnd, chatBLastTurnEnd);
+            });
+            return chatsSortedByLastTurnEnd[0].checkpoints.read(reader)?.lastCheckpointRef;
+        });
+        this.originalCheckpointRef = derived(reader => {
+            const modifiedCheckpointRef = this.modifiedCheckpointRef.read(reader);
+            return modifiedCheckpointRef ? `${modifiedCheckpointRef}^` : undefined;
+        });
+        const changesPromiseObs = derived(reader => {
+            const originalCheckpointRef = this.originalCheckpointRef.read(reader);
+            const modifiedCheckpointRef = this.modifiedCheckpointRef.read(reader);
+            if (!originalCheckpointRef || !modifiedCheckpointRef) {
+                return constObservable([]);
+            }
+            const diffPromise = changesetResolver.resolve(originalCheckpointRef, modifiedCheckpointRef);
+            return ( new ObservablePromise(diffPromise)).resolvedValue;
+        });
+        this.isLoadingChanges = derived(reader => {
+            return changesPromiseObs.read(reader).read(reader) === undefined;
+        });
+        this.changes = derivedOpts({
+            equalsFn: sessionFileChangesEqual
+        }, reader => {
+            return changesPromiseObs.read(reader).read(reader) ?? [];
+        });
+        this.isEnabled = derived(
+            reader => this.originalCheckpointRef.read(reader) !== undefined && this.modifiedCheckpointRef.read(reader) !== undefined
+        );
+    }
+}
+function sortDateDesc(dateA, dateB) {
+    const chatALastTurnEnd = dateA?.getTime();
+    const chatBLastTurnEnd = dateB?.getTime();
+    if (!chatALastTurnEnd && !chatBLastTurnEnd) {
+        return 0;
+    }
+    if (!chatALastTurnEnd) {
+        return 1;
+    }
+    if (!chatBLastTurnEnd) {
+        return -1;
+    }
+    return chatBLastTurnEnd - chatALastTurnEnd;
+}
+function toIChatSessionFileChange2(changes, originalRef, modifiedRef) {
+    return changes.map(change => ({
+        uri: change.uri,
+        originalUri: change.originalUri ? originalRef ? change.originalUri.with({
+            scheme: "git",
+            query: JSON.stringify({
+                path: change.originalUri.fsPath,
+                ref: originalRef
+            })
+        }) : change.originalUri : undefined,
+        modifiedUri: change.modifiedUri ? modifiedRef ? change.modifiedUri.with({
+            scheme: "git",
+            query: JSON.stringify({
+                path: change.modifiedUri.fsPath,
+                ref: modifiedRef
+            })
+        }) : change.modifiedUri : undefined,
+        insertions: change.insertions,
+        deletions: change.deletions
+    }));
+}
+
+export { AllChangesChangeset, BranchChangesChangeset, LastTurnChangesChangeset, UncommittedChangesChangeset, createChangesets };