1
>
/*---------------------------------------------------------------------------------------------
sessionContextKeys.ts
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import { IReader } from '../../../../base/common/observable.js';
7
>
import { isEqual } from '../../../../base/common/resources.js';
8
>
import { IContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
9
>
import {
10
>
SessionHasChangesContext,
11
>
SessionHasPullRequestContext,
12
>
SessionHasWorkspaceContext,
13
>
IsQuickChatSessionContext,
14
>
SessionIsArchivedContext,
15
>
SessionIsCreatedContext,
16
>
SessionIsReadContext,
17
>
SessionIsStickyContext,
18
>
SessionProviderIdContext,
19
>
SessionSupportsDeleteContext,
20
>
SessionSupportsMultipleChatsContext,
21
>
SessionSupportsForkContext,
22
>
SessionSupportsSideChatContext,
23
>
SessionSupportsRenameContext,
24
>
SessionTypeContext,
25
>
SessionWorkspaceIsVirtualContext,
26
>
SessionIdContext,
27
>
SessionHasMultipleCommittedChatsContext,
28
>
SessionShouldShowChatTabsContext,
29
>
SessionHasMultipleOpenChatsContext,
30
>
SessionActiveChatIsClosableContext,
31
>
SessionActiveChatIsDeletableContext,
32
>
SessionActiveChatHasSubagentsContext,
33
>
SessionHasGitRepositoryContext,
34
>
} from '../../../common/contextkeys.js';
35
>
import { ChatOriginKind, getChatCapabilities, ISession, SessionStatus } from './session.js';
36
>
import { IActiveSession } from './sessionsManagement.js';
37
>
38
>
/**
39
>
* The set of session context keys bound to a single {@link IContextKeyService}.
40
>
*/
41
>
interface ISessionContextKeys {
42
>
readonly sessionId: IContextKey<string>;
43
>
readonly providerId: IContextKey<string>;
44
>
readonly type: IContextKey<string>;
45
>
readonly isArchived: IContextKey<boolean>;
46
>
readonly isRead: IContextKey<boolean>;
47
>
readonly supportsMultipleChats: IContextKey<boolean>;
48
>
readonly supportsFork: IContextKey<boolean>;
49
>
readonly supportsSideChat: IContextKey<boolean>;
50
>
readonly supportsRename: IContextKey<boolean>;
51
>
readonly supportsDelete: IContextKey<boolean>;
52
>
readonly workspaceIsVirtual: IContextKey<boolean>;
53
>
readonly hasGitRepository: IContextKey<boolean>;
54
>
readonly hasChanges: IContextKey<boolean>;
55
>
readonly hasPullRequest: IContextKey<boolean>;
56
>
readonly hasWorkspace: IContextKey<boolean>;
57
>
readonly isQuickChat: IContextKey<boolean>;
58
>
readonly isCreated: IContextKey<boolean>;
59
>
readonly sticky: IContextKey<boolean>;
60
>
readonly hasMultipleCommittedChats: IContextKey<boolean>;
61
>
readonly shouldShowChatTabs: IContextKey<boolean>;
62
>
readonly hasMultipleOpenChats: IContextKey<boolean>;
63
>
readonly activeChatIsClosable: IContextKey<boolean>;
64
>
readonly activeChatIsDeletable: IContextKey<boolean>;
65
>
readonly activeChatHasSubagents: IContextKey<boolean>;
66
>
}
67
>
68
>
/**
69
>
* Caches the bound context keys per {@link IContextKeyService}. Binding a
70
>
* {@link RawContextKey} resets it to its default value, so re-binding on every
71
>
* call (these helpers run inside `autorun`s) would churn the keys and emit
72
>
* spurious change events. Binding once per service and reusing the bound keys
73
>
* lets {@link IContextKey.set} short-circuit unchanged values instead. The map
74
>
* is weak so entries are released once the service is disposed and collected.
75
>
*/
76
>
const boundKeysByService = new WeakMap<IContextKeyService, ISessionContextKeys>();
77
>
78
>
function getBoundKeys(contextKeyService: IContextKeyService): ISessionContextKeys {
79
>
let keys = boundKeysByService.get(contextKeyService);
80
>
if (!keys) {
81
>
keys = {
82
>
sessionId: SessionIdContext.bindTo(contextKeyService),
83
>
providerId: SessionProviderIdContext.bindTo(contextKeyService),
84
>
type: SessionTypeContext.bindTo(contextKeyService),
85
>
isArchived: SessionIsArchivedContext.bindTo(contextKeyService),
86
>
isRead: SessionIsReadContext.bindTo(contextKeyService),
87
>
supportsMultipleChats: SessionSupportsMultipleChatsContext.bindTo(contextKeyService),
88
>
supportsFork: SessionSupportsForkContext.bindTo(contextKeyService),
89
>
supportsSideChat: SessionSupportsSideChatContext.bindTo(contextKeyService),
90
>
supportsRename: SessionSupportsRenameContext.bindTo(contextKeyService),
91
>
supportsDelete: SessionSupportsDeleteContext.bindTo(contextKeyService),
92
>
workspaceIsVirtual: SessionWorkspaceIsVirtualContext.bindTo(contextKeyService),
93
>
hasGitRepository: SessionHasGitRepositoryContext.bindTo(contextKeyService),
94
>
hasChanges: SessionHasChangesContext.bindTo(contextKeyService),
95
>
hasPullRequest: SessionHasPullRequestContext.bindTo(contextKeyService),
96
>
hasWorkspace: SessionHasWorkspaceContext.bindTo(contextKeyService),
97
>
isQuickChat: IsQuickChatSessionContext.bindTo(contextKeyService),
98
>
isCreated: SessionIsCreatedContext.bindTo(contextKeyService),
99
>
sticky: SessionIsStickyContext.bindTo(contextKeyService),
100
>
hasMultipleCommittedChats: SessionHasMultipleCommittedChatsContext.bindTo(contextKeyService),
101
>
shouldShowChatTabs: SessionShouldShowChatTabsContext.bindTo(contextKeyService),
102
>
hasMultipleOpenChats: SessionHasMultipleOpenChatsContext.bindTo(contextKeyService),
103
>
activeChatIsClosable: SessionActiveChatIsClosableContext.bindTo(contextKeyService),
104
>
activeChatIsDeletable: SessionActiveChatIsDeletableContext.bindTo(contextKeyService),
105
>
activeChatHasSubagents: SessionActiveChatHasSubagentsContext.bindTo(contextKeyService),
106
>
};
107
>
boundKeysByService.set(contextKeyService, keys);
108
>
}
109
>
return keys;
110
>
}
111
>
112
>
/**
113
>
* Sets every context key that can be derived from an {@link ISession} on the
114
>
* given context key service. The service may be the global/root service (so the
115
>
* keys reflect the active session) or a scoped service owned by an isolated
116
>
* component (e.g. a session view), in which case the keys are scoped to that
117
>
* component's session.
118
>
*
119
>
* When invoked from within an `autorun`/`derived`, pass the `reader` so the
120
>
* observable session properties are tracked and the keys are re-applied on
121
>
* change. Pass `undefined` for a one-shot read (equivalent to `.get()`).
122
>
*
123
>
* Passing `undefined` for `session` resets the keys to their defaults (e.g. for
124
>
* the empty new-session slot).
125
>
*/
126
>
export function setSessionContextKeys(session: ISession | undefined, contextKeyService: IContextKeyService, reader: IReader | undefined): void {
127
>
const keys = getBoundKeys(contextKeyService);
128
>
keys.sessionId.set(session?.sessionId ?? '');
129
>
keys.providerId.set(session?.providerId ?? '');
130
>
keys.type.set(session?.sessionType ?? '');
131
>
keys.isArchived.set(session?.isArchived.read(reader) ?? false);
132
>
keys.isRead.set(session?.isRead.read(reader) ?? true);
133
>
const capabilities = session?.capabilities.read(reader);
134
>
keys.supportsMultipleChats.set(capabilities?.supportsMultipleChats ?? false);
135
>
keys.supportsFork.set(capabilities?.supportsFork ?? false);
136
>
keys.supportsSideChat.set(capabilities?.supportsSideChat ?? false);
137
>
keys.supportsRename.set(capabilities?.supportsRename ?? false);
138
>
keys.supportsDelete.set(capabilities?.supportsDelete ?? false);
139
>
const workspace = session?.workspace.read(reader);
140
>
keys.workspaceIsVirtual.set(workspace?.isVirtualWorkspace ?? true);
141
>
keys.hasGitRepository.set(session?.hasGitRepository?.read(reader) ?? workspace?.folders.some(folder => folder.gitRepository !== undefined) ?? false);
142
>
143
>
// Mirror the changes pill: the default changeset, falling back to the session's changes.
144
>
const defaultChangeset = session?.changesets.read(reader)?.find(c => c.isDefault.read(reader));
145
>
let insertions = 0;
146
>
let deletions = 0;
147
>
for (const change of defaultChangeset?.changes.read(reader) ?? session?.changes.read(reader) ?? []) {
148
insertions += change.insertions;
149
deletions += change.deletions;
150
}
152
>
153
>
const pullRequest = session?.workspace.read(reader)?.folders[0]?.gitRepository?.gitHubInfo.read(reader)?.pullRequest;
154
>
keys.hasPullRequest.set(!!pullRequest);
155
>
156
>
keys.hasWorkspace.set(!!session?.workspace.read(reader)?.label);
157
>
158
>
// Sourced from the session's `isQuickChat` tag — never inferred from
159
>
// `workspace === undefined` (which is also transiently true for a
160
>
// still-resolving workspace session).
161
>
keys.isQuickChat.set(!!session && (session.isQuickChat?.read(reader) ?? false));
162
>
163
>
}
164
>
165
>
/**
166
>
* Sets every context key that can be derived from an {@link IActiveSession} on
167
>
* the given context key service. This is a superset of
168
>
* {@link setSessionContextKeys} that also applies the keys which only exist on
169
>
* an active (visible) session, then delegates to it for the shared keys.
170
>
*
171
>
* See {@link setSessionContextKeys} for the `reader` and `undefined` semantics.
172
>
*/
173
>
export function setActiveSessionContextKeys(session: IActiveSession | undefined, contextKeyService: IContextKeyService, reader: IReader | undefined): void {
174
setSessionContextKeys(session, contextKeyService, reader);
175
const keys = getBoundKeys(contextKeyService);