@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 03:37 UTC

main
ts 254 lines 8.94 KB
Raw
1 import type {
2 EnvironmentId,
3 ScopedProjectRef,
4 SidebarProjectGroupingMode,
5 } from "@t3tools/contracts";
6 import {
7 buildProjectGroups,
8 derivePhysicalProjectKey,
9 isPickableProjectMember,
10 resolveScratchProjectScopeKey,
11 type ProjectGroupingSettings,
12 } from "@t3tools/client-runtime/state/project-grouping";
13 import { msg } from "gt-react";
14
15 import { m, type MessageResolver } from "./i18n/messages";
16 import type { Project } from "./types";
17
18 export const PROJECT_GROUPING_MODE_LABELS: Record<SidebarProjectGroupingMode, string> = {
19 repository: msg("Group by repository", { $context: "sidebar project grouping mode" }),
20 repository_path: msg("Group by repository path", { $context: "sidebar project grouping mode" }),
21 separate: msg("Keep separate", { $context: "sidebar project grouping mode" }),
22 };
23
24 export function withProjectGroupingOverride(
25 overrides: Readonly<Record<string, SidebarProjectGroupingMode>> | undefined,
26 overrideKey: string,
27 selection: SidebarProjectGroupingMode | "inherit",
28 ): Record<string, SidebarProjectGroupingMode> {
29 const next = { ...overrides };
30 if (selection === "inherit") delete next[overrideKey];
31 else next[overrideKey] = selection;
32 return next;
33 }
34
35 export type EnvironmentPresence = "local-only" | "remote-only" | "mixed";
36
37 export interface SidebarProjectGroupMember extends Project {
38 physicalProjectKey: string;
39 environmentLabel: string | null;
40 }
41
42 export interface SidebarProjectSnapshot extends Project {
43 projectKey: string;
44 displayName: string;
45 groupedProjectCount: number;
46 environmentPresence: EnvironmentPresence;
47 allRemoteMembersAreDesktopLocal: boolean;
48 allRemoteMembersAreWsl: boolean;
49 memberProjects: readonly SidebarProjectGroupMember[];
50 memberProjectRefs: readonly ScopedProjectRef[];
51 remoteEnvironmentLabels: readonly string[];
52 pinned: boolean;
53 archived: boolean;
54 }
55
56 export function projectGroupsSpanEnvironments(
57 groups: ReadonlyArray<Pick<SidebarProjectSnapshot, "memberProjects">>,
58 ): boolean {
59 const environmentIds = new Set<EnvironmentId>();
60 for (const group of groups) {
61 for (const member of group.memberProjects) {
62 environmentIds.add(member.environmentId);
63 if (environmentIds.size > 1) return true;
64 }
65 }
66 return false;
67 }
68
69 export interface SidebarProjectPickerEntry {
70 group: SidebarProjectSnapshot;
71 targetProject: SidebarProjectGroupMember;
72 isPreferred: boolean;
73 }
74
75 export function getSidebarProjectSettingsKey(
76 group: SidebarProjectSnapshot,
77 settings: ProjectGroupingSettings,
78 projects: ReadonlyArray<Project>,
79 projectRef?: ScopedProjectRef,
80 ): string {
81 if (!group.isScratch) return group.projectKey;
82 const project =
83 group.memberProjects.find(
84 (member) =>
85 member.environmentId === projectRef?.environmentId && member.id === projectRef.projectId,
86 ) ??
87 group.memberProjects.find((member) => member.environmentId === projectRef?.environmentId) ??
88 group;
89 return (
90 buildPhysicalToLogicalProjectKeyMap({ projects, settings, primaryEnvironmentId: null }).get(
91 derivePhysicalProjectKey(project),
92 ) ?? group.projectKey
93 );
94 }
95
96 export function resolveSidebarProjectScopeKey(input: {
97 readonly groups: ReadonlyArray<SidebarProjectSnapshot>;
98 readonly key: string | null;
99 readonly settings?: ProjectGroupingSettings;
100 readonly canClearMissingScope?: boolean;
101 }): string | null {
102 if (input.key === null) return null;
103 const group =
104 input.groups.find((candidate) => candidate.projectKey === input.key) ??
105 input.groups.find(
106 (candidate) =>
107 candidate.isScratch &&
108 resolveScratchProjectScopeKey(input.key, candidate.memberProjects, input.settings) ===
109 candidate.projectKey,
110 );
111 return group?.projectKey ?? (input.canClearMissingScope ? null : input.key);
112 }
113
114 export function resolveSidebarProjectScopeKeys(input: {
115 readonly groups: ReadonlyArray<SidebarProjectSnapshot>;
116 readonly keys: ReadonlyArray<string>;
117 readonly settings?: ProjectGroupingSettings;
118 readonly canClearMissingScope?: boolean;
119 }): string[] {
120 return [
121 ...new Set(input.keys.flatMap((key) => resolveSidebarProjectScopeKey({ ...input, key }) ?? [])),
122 ];
123 }
124
125 export function buildPhysicalToLogicalProjectKeyMap(input: {
126 projects: ReadonlyArray<Project>;
127 settings: ProjectGroupingSettings;
128 primaryEnvironmentId: EnvironmentId | null;
129 }): Map<string, string> {
130 const mapping = new Map<string, string>();
131 const groups = buildProjectGroups({
132 projects: input.projects,
133 settings: input.settings,
134 preferredEnvironmentId: input.primaryEnvironmentId,
135 });
136 for (const group of groups) {
137 for (const member of group.members) {
138 mapping.set(member.physicalProjectKey, group.key);
139 }
140 }
141 return mapping;
142 }
143
144 export function buildSidebarProjectSnapshots(
145 input: {
146 projects: ReadonlyArray<Project>;
147 settings: ProjectGroupingSettings;
148 groupScratchProjects?: boolean;
149 primaryEnvironmentId: EnvironmentId | null;
150 resolveEnvironmentLabel: (environmentId: EnvironmentId) => string | null;
151 isDesktopLocalEnvironment?: (environmentId: EnvironmentId) => boolean;
152 isWslEnvironment?: (environmentId: EnvironmentId) => boolean;
153 },
154 resolve: MessageResolver = m,
155 ): SidebarProjectSnapshot[] {
156 return buildProjectGroups(
157 {
158 projects: input.projects,
159 groupScratchProjects: input.groupScratchProjects ?? false,
160 settings: input.settings,
161 preferredEnvironmentId: input.primaryEnvironmentId,
162 },
163 resolve,
164 ).map((group): SidebarProjectSnapshot => {
165 const members = group.members.map(
166 ({ physicalProjectKey, project }): SidebarProjectGroupMember => ({
167 ...project,
168 physicalProjectKey,
169 environmentLabel: input.resolveEnvironmentLabel(project.environmentId),
170 }),
171 );
172 const representative =
173 members.find(
174 (member) =>
175 member.environmentId === group.representative.environmentId &&
176 member.id === group.representative.id,
177 ) ?? members[0]!;
178
179 const hasLocal =
180 input.primaryEnvironmentId !== null &&
181 members.some((member) => member.environmentId === input.primaryEnvironmentId);
182 const hasRemote =
183 input.primaryEnvironmentId !== null
184 ? members.some((member) => member.environmentId !== input.primaryEnvironmentId)
185 : false;
186 const remoteMembers = members.filter(
187 (member) =>
188 input.primaryEnvironmentId !== null && member.environmentId !== input.primaryEnvironmentId,
189 );
190 const remoteEnvironmentLabels = remoteMembers
191 .flatMap((member) => (member.environmentLabel ? [member.environmentLabel] : []))
192 .filter((label, index, labels) => labels.indexOf(label) === index);
193 const isDesktopLocal = input.isDesktopLocalEnvironment ?? (() => false);
194 const isWsl = input.isWslEnvironment ?? (() => false);
195 const allRemoteMembersAreDesktopLocal =
196 remoteMembers.length > 0 &&
197 remoteMembers.every((member) => isDesktopLocal(member.environmentId));
198 const allRemoteMembersAreWsl =
199 remoteMembers.length > 0 && remoteMembers.every((member) => isWsl(member.environmentId));
200
201 return {
202 ...representative,
203 projectKey: group.key,
204 displayName: group.label,
205 groupedProjectCount: members.length,
206 environmentPresence:
207 hasLocal && hasRemote ? "mixed" : hasRemote ? "remote-only" : "local-only",
208 allRemoteMembersAreDesktopLocal,
209 allRemoteMembersAreWsl,
210 memberProjects: members,
211 memberProjectRefs: group.memberProjectRefs,
212 remoteEnvironmentLabels,
213 pinned: group.pinned,
214 archived: group.archived,
215 };
216 });
217 }
218
219 export function buildSidebarProjectPickerEntries(input: {
220 groups: ReadonlyArray<SidebarProjectSnapshot>;
221 preferredProjectRef: ScopedProjectRef | null;
222 }) {
223 const preferredProjectRef = input.preferredProjectRef;
224 const entries = input.groups.flatMap((group): SidebarProjectPickerEntry[] => {
225 const members = group.memberProjects.filter(isPickableProjectMember);
226 const isPreferred = preferredProjectRef
227 ? group.memberProjectRefs.some(
228 (projectRef) =>
229 projectRef.environmentId === preferredProjectRef.environmentId &&
230 projectRef.projectId === preferredProjectRef.projectId,
231 )
232 : false;
233 const preferredProject = preferredProjectRef
234 ? (members.find(
235 (project) =>
236 project.environmentId === preferredProjectRef.environmentId &&
237 project.id === preferredProjectRef.projectId,
238 ) ?? members.find((project) => project.environmentId === preferredProjectRef.environmentId))
239 : null;
240 const targetProject =
241 preferredProject ??
242 members.find(
243 (project) => project.environmentId === group.environmentId && project.id === group.id,
244 ) ??
245 members[0];
246 if (!targetProject) return [];
247
248 return [{ group, targetProject, isPreferred }];
249 });
250 // The current project leads, even ahead of pinned projects.
251 const preferred = entries.find((entry) => entry.isPreferred);
252 if (!preferred) return entries;
253 return [preferred, ...entries.filter((entry) => entry !== preferred)];
254 }