Skip to content
Source
Sign inSign up
Open History to see the last commit

new-task-flow-provider.tsx

943 lines35.0 KB

1import { ActiveNewTaskContext } from "../../state/active-new-task";
2import { resolveNewThreadModelSelection } from "@t3tools/shared/usageLimits";
3import { useNowMinuteMs } from "../../lib/clock";
4import * as Dialog from "../../components/ui/Dialog";
5import React, { useEffect, useRef, useState } from "react";
6​
7import type {
8 EnvironmentId,
9 ModelSelection,
10 ProviderOptionSelection,
11 RuntimeMode,
12 ServerProvider,
13} from "@t3tools/contracts";
14import {
15 CommandId,
16 DEFAULT_PROVIDER_INTERACTION_MODE,
17 MessageId,
18 repositoryGroupingKeyOf,
19 ThreadId,
20} from "@t3tools/contracts";
21import { threadContextsOutsideEnvironment } from "@t3tools/shared/composerContextReferences";
22import { isTriagePrompt, replaceTriagePlaybookLink } from "@t3tools/shared/triagePrompt";
23import * as Arr from "effect/Array";
24import { pipe } from "effect/Function";
25​
26import { useProjects, useServerConfigs, useThreadShells } from "../../state/entities";
27import type { TurnCommandMetadata } from "../../lib/commandMetadata";
28import type { DraftComposerAttachment } from "../../lib/composerImages";
29import type { ModelOption, ProviderGroup } from "../../lib/modelOptions";
30import {
31 buildModelOptions,
32 groupByProvider,
33 resolveDefaultableModelSelection,
34 resolveNewTaskModelSelection,
35 resolveSelectableModelSelection,
36 serverConfigForCwd,
37} from "../../lib/modelOptions";
38import { scopedProjectKey } from "../../lib/scopedEntities";
39import { useAtomValue } from "@effect/atom-react";
40import { appAtomRegistry } from "../../state/atom-registry";
41import { projectEnvironment } from "../../state/projects";
42import { useLinkedEnvironments } from "../../state/peerLinks";
43import { useEnvironmentQuery } from "../../state/query";
44import { useAtomCommand } from "../../state/use-atom-command";
45import {
46 appendComposerDraftAttachments,
47 type ComposerDraftInsertion,
48 type ComposerDraftWorkspaceSelection,
49 composerDraftsLoadedAtom,
50 createNewTaskDraft,
51 getComposerDraftSnapshot,
52 isNewTaskDraftKey,
53 removeComposerDraftAttachment,
54 replaceComposerDraftAttachments,
55 retargetNewTaskDraft,
56 setComposerDraftText,
57 setStickyComposerModelSelection,
58 updateComposerDraftSettings,
59 useComposerDraft,
60 useStickyComposerModelSelection,
61} from "../../state/use-composer-drafts";
62import {
63 rememberModelOptions,
64 withRememberedModelOptions,
65} from "../../state/use-model-option-memory";
66import { useBranches, usePaginatedBranches } from "../../state/queries";
67import { vcsEnvironment } from "../../state/vcs";
68import { type QueuedThreadMessage } from "../../state/thread-outbox";
69import {
70 setPendingConnectionError,
71 useRemoteConnectionStatus,
72 useSavedRemoteConnections,
73} from "../../state/use-remote-environment-registry";
74import { availableScratchWorkspaceRoot } from "@t3tools/client-runtime/operations/projects";
75import {
76 isAtomCommandInterrupted,
77 squashAtomCommandFailure,
78} from "@t3tools/client-runtime/state/runtime";
79import { EnvironmentProject } from "@t3tools/client-runtime/state/shell";
80import { type VcsRef } from "@t3tools/client-runtime/state/vcs";
81import {
82 buildHomeProjectScopes,
83 sortHomeProjectScopes,
84 type HomeProjectScope,
85} from "../home/homeThreadList";
86import { useMobileProjectGroupingSettings } from "../../state/project-grouping";
87import {
88 resolveNewTaskDraftWorkspace,
89 resolveNewTaskBranchWorktreePath,
90 resolveNewTaskLocalWorkspaceSelection,
91} from "./new-task-context-presentation";
92import { isSameRepository, resolveEnvironmentProjectMatch } from "./new-task-project-selection";
93import { useNewTaskProjectDefaults } from "./use-new-task-project-defaults";
94import { resolveNewThreadRuntimeMode } from "./thread-settings-options";
95import { resolveProjectThreadCreationBranch } from "./projectThreadCreationValidation";
96import {
97 INACTIVE_FLOW_KEY,
98 type NewTaskFlowState,
99 newTaskFlowStateAtom,
100 readNewTaskFlowState,
101 resolveRouteDraft,
102 type RouteDraftResolution,
103 stampedEnvironmentProjectsLoading,
104 updateNewTaskFlowState,
105} from "./new-task-flow-state";
106import { usePrepareTriage } from "../triage/usePrepareTriage";
107import { useEnvironmentShellReadiness } from "../../state/shell";
108import { useConnectionsReady, useWorkspaceEnvironments } from "../../state/workspace";
109​
110type WorkspaceMode = "local" | "worktree";
111​
112export function branchBadgeLabel(input: {
113 readonly branch: VcsRef;
114 readonly project: EnvironmentProject | null;
115}): string | null {
116 if (input.branch.current) {
117 return "current";
118 }
119 if (input.branch.worktreePath && input.branch.worktreePath !== input.project?.workspaceRoot) {
120 return "worktree";
121 }
122 if (input.branch.isRemote) {
123 return "remote";
124 }
125 if (input.branch.isDefault) {
126 return "default";
127 }
128 return null;
130​
131type NewTaskFlowContextValue = {
132 readonly activeNewTask: { readonly pendingKey: string | null } | null;
133 readonly projectScopes: ReadonlyArray<HomeProjectScope>;
134 readonly selectedEnvironmentId: EnvironmentId | null;
135 readonly selectedProjectKey: string | null;
136 readonly selectedModelKey: string | null;
137 readonly workspaceMode: WorkspaceMode;
138 readonly isGitRepo: boolean;
139 readonly isGitRepoKnown: boolean;
140 readonly canChooseWorkspace: boolean;
141 readonly selectedBranchName: string | null;
142 readonly selectedWorktreePath: string | null;
143 /** Where the draft's agent will run: the selected worktree, else the project root. */
144 readonly workspaceCwd: string | null;
145 readonly resolveWorkspaceSelection: (
146 selection: ComposerDraftWorkspaceSelection | undefined,
147 ) => ComposerDraftWorkspaceSelection;
148 readonly startFromOrigin: boolean;
149 readonly pullRequestReference: string | undefined;
150 readonly draftKey: string | null;
151 readonly prompt: string;
152 readonly attachments: ReadonlyArray<DraftComposerAttachment>;
153 readonly submitting: boolean;
154 readonly branchesLoading: boolean;
155 readonly availableBranches: ReadonlyArray<VcsRef>;
156 readonly currentCheckoutBranchName: string | null;
157 readonly runtimeMode: RuntimeMode;
158 readonly expandedProvider: string | null;
159 readonly environments: ReadonlyArray<{
160 readonly environmentId: EnvironmentId;
161 readonly environmentLabel: string;
162 }>;
163 readonly selectedProject: EnvironmentProject | null;
164 /** The machines the selected project's environment links to, whose threads it can read. */
165 readonly linkedEnvironments: ReadonlyMap<EnvironmentId, string>;
166 readonly isScratchDraft: boolean;
167 readonly modelOptions: ReadonlyArray<ModelOption>;
168 readonly selectedModel: ModelSelection | null;
169 readonly selectedModelOption: ModelOption | null;
170 readonly selectedProviderStatus: ServerProvider | null;
171 readonly providerGroups: ReadonlyArray<ProviderGroup>;
172 readonly setProject: (project: EnvironmentProject) => void;
173 /** The flow's project, read when a continuation resumes after an await. */
174 readonly getSelectedProjectKey: () => string | null;
175 /**
176 * The route this flow serves when its draft cannot open: the draft is gone
177 * (`missing`) or only its project is (`pickProject`). Only the topmost draft
178 * route is served, so a screen compares `draftId` with its own draft id.
179 */
180 readonly unopenableRouteDraft: {
181 readonly draftId: string;
182 readonly kind: "missing" | "pickProject";
183 } | null;
184 readonly selectEnvironment: (environmentId: EnvironmentId) => void;
185 readonly switchEnvironment: (environmentId: EnvironmentId) => Promise<boolean>;
186 readonly switchingToEnvironmentId: EnvironmentId | null;
187 readonly setSelectedModelKey: (
188 key: string | null,
189 options?: ReadonlyArray<ProviderOptionSelection>,
190 ) => void;
191 readonly setWorkspaceMode: (mode: WorkspaceMode) => void;
192 readonly selectBranch: (branch: VcsRef) => void;
193 readonly setStartFromOrigin: (value: boolean) => void;
194 readonly buildPendingTaskMessage: (
195 metadata: TurnCommandMetadata,
196 options?: {
197 readonly currentCheckoutBranch?: string | null;
198 },
199 ) => QueuedThreadMessage | null;
200 readonly setPrompt: (value: string) => void;
201 readonly replaceAttachments: (attachments: ReadonlyArray<DraftComposerAttachment>) => void;
202 /** Appends draft attachments; returns how many the live cap rejected. */
203 readonly appendAttachments: (
204 attachments: ReadonlyArray<DraftComposerAttachment>,
205 insertion?: ComposerDraftInsertion,
206 ) => number;
207 readonly removeAttachment: (imageId: string) => void;
208 readonly clearAttachments: () => void;
209 readonly setSubmitting: (value: boolean) => void;
210 readonly loadBranches: () => void;
211 readonly setRuntimeMode: (value: RuntimeMode) => void;
212 readonly setSelectedModelOptions: (
213 value: ReadonlyArray<ProviderOptionSelection> | undefined,
214 ) => void;
215 readonly setExpandedProvider: (value: string | null) => void;
216};
217​
218const NewTaskFlowContext = React.createContext<NewTaskFlowContextValue | null>(null);
219​
220export function NewTaskFlowProvider(
221 props: React.PropsWithChildren<{
222 active?: boolean;
223 /** Identifies the draft route this flow serves; a new key starts a fresh flow. */
224 flowKey?: string;
225 routeDraftId?: string;
226 }>,
227) {
228 const projects = useProjects();
229 const threads = useThreadShells();
230 const { savedConnectionsById } = useSavedRemoteConnections();
231 const groupingSettings = useMobileProjectGroupingSettings();
232​
233 const projectScopes = sortHomeProjectScopes({
234 scopes: buildHomeProjectScopes({
235 projects,
236 environmentId: null,
237 projectGroupingMode: groupingSettings.sidebarProjectGroupingMode,
238 }),
239 threads,
240 pendingTasks: [],
241 projectSortOrder: "updated_at",
242 });
243​
244 const flowKey = props.flowKey ?? INACTIVE_FLOW_KEY;
245 const storedFlowState = useAtomValue(newTaskFlowStateAtom(flowKey));
246 const draftsLoaded = useAtomValue(composerDraftsLoadedAtom);
247 // A draft route opened from a list row, a deep link, or restored state binds
248 // its draft here until the flow's first write stores the binding.
249 const routeDraft = useComposerDraft(
250 storedFlowState.draftKey === null ? (props.routeDraftId ?? null) : null,
251 );
252 // Readiness of the environment the route's draft is stamped to; another
253 // environment's projects loading first says nothing about it.
254 const stampedEnvironmentId = routeDraft.project?.environmentId ?? null;
255 const connectionsReady = useConnectionsReady();
256 const stampedEnvironmentConnection =
257 useWorkspaceEnvironments().find(
258 (environment) => environment.environmentId === stampedEnvironmentId,
259 )?.connectionState ?? null;
260 const stampedEnvironmentShell = useEnvironmentShellReadiness(stampedEnvironmentId);
261 const stampedEnvironmentLoading = stampedEnvironmentProjectsLoading({
262 connectionsReady,
263 connectionState: stampedEnvironmentConnection,
264 shellCacheRead: stampedEnvironmentShell.cacheRead,
265 shellStatus: stampedEnvironmentShell.status,
266 shellHasError: stampedEnvironmentShell.hasError,
267 });
268 const resolveRoute = (
269 flow: NewTaskFlowState,
270 loaded: boolean,
271 stamp: Parameters<typeof resolveRouteDraft>[0]["stamp"],
272 ): RouteDraftResolution =>
273 resolveRouteDraft({
274 flow,
275 routeDraftId: props.routeDraftId,
276 draftsLoaded: loaded,
277 stamp,
278 projects,
279 stampedEnvironmentLoading,
280 });
281 const routeDraftResolution = resolveRoute(storedFlowState, draftsLoaded, routeDraft.project);
282 const flowState =
283 routeDraftResolution.kind === "open" ? routeDraftResolution.flow : storedFlowState;
284 const {
285 environmentId: selectedEnvironmentIdOverride,
286 projectKey: selectedProjectKey,
287 draftKey: activeDraftKey,
288 submitting,
289 expandedProvider,
290 } = flowState;
291 // Continuations read the flow at use time, with the route's draft applied.
292 const readFlow = (): NewTaskFlowState => {
293 const stored = readNewTaskFlowState(flowKey);
294 const resolution = resolveRoute(
295 stored,
296 appAtomRegistry.get(composerDraftsLoadedAtom),
297 props.routeDraftId === undefined
298 ? undefined
299 : getComposerDraftSnapshot(props.routeDraftId).project,
300 );
301 return resolution.kind === "open" ? resolution.flow : stored;
302 };
303 // Every flow write stores the route's draft binding along with it, so the
304 // binding outlives the draft's project stamp (submit clears it).
305 const updateFlow = (patch: Partial<NewTaskFlowState>) =>
306 updateNewTaskFlowState(flowKey, { ...readFlow(), ...patch });
307 const selectedEnvironmentId =
308 selectedEnvironmentIdOverride !== null &&
309 projects.some((project) => project.environmentId === selectedEnvironmentIdOverride)
310 ? selectedEnvironmentIdOverride
311 : (projects[0]?.environmentId ?? null);
312 const projectsForEnvironment = pipe(
313 projects,
314 Arr.filter((project) => project.environmentId === selectedEnvironmentId),
315 );
316​
317 // A route draft still waiting for its environment has no project yet: the
318 // fallback would show, and could send to, another environment's project.
319 const selectedProject =
320 routeDraftResolution.kind === "pending"
321 ? null
322 : (projectsForEnvironment.find(
323 (project) => scopedProjectKey(project.environmentId, project.id) === selectedProjectKey,
324 ) ??
325 projectsForEnvironment[0] ??
326 null);
327​
328 const linkedEnvironments = useLinkedEnvironments(selectedProject?.environmentId ?? null);
329 const storedStickyModelSelection = useStickyComposerModelSelection();
330 const modelSelectionNow = useNowMinuteMs();
331 const projectDefaults = useNewTaskProjectDefaults(selectedProject);
332 const isScratchDraft = projectDefaults.isScratch;
333 const serverConfigs = useServerConfigs();
334 const { connectedEnvironments } = useRemoteConnectionStatus();
335 const selectedProjectDraftKey = selectedProject ? activeDraftKey : null;
336 // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- creates the persistent draft in the new-task flow store once a project is selected, before the composer mounts
337 useEffect(() => {
338 // A route that names a draft binds that draft, or returns to the picker.
339 if (
340 props.active === false ||
341 props.routeDraftId !== undefined ||
342 activeDraftKey !== null ||
343 selectedProject === null
344 ) {
345 return;
346 }
347 // Creates the persistent draft once the project selection is ready; the key must exist before the composer mounts.
348 updateNewTaskFlowState(flowKey, {
349 draftKey: createNewTaskDraft({
350 environmentId: selectedProject.environmentId,
351 projectId: selectedProject.id,
352 }),
353 });
354 }, [activeDraftKey, flowKey, selectedProject, props.active, props.routeDraftId]);
355 const activePendingKey =
356 props.active === false
357 ? null
358 : props.routeDraftId
359 ? `draft-task:${props.routeDraftId}`
360 : selectedProjectDraftKey
361 ? `draft-task:${selectedProjectDraftKey}`
362 : null;
363 const activeNewTask = props.active === false ? null : { pendingKey: activePendingKey };
364 const selectedProjectDraft = useComposerDraft(selectedProjectDraftKey);
365 const prompt = selectedProjectDraft.text;
366 const attachments = selectedProjectDraft.attachments;
367 const projectGitStatus = useEnvironmentQuery(
368 props.active !== false && selectedProject !== null && selectedProject.workspaceRoot !== ""
369 ? vcsEnvironment.status({
370 environmentId: selectedProject.environmentId,
371 input: { cwd: selectedProject.workspaceRoot },
372 })
373 : null,
374 );
375 const currentCheckoutBranchName = projectGitStatus.data?.refName ?? null;
376 // The unfiltered ref list also provides repository capability while offline.
377 const projectBranches = useBranches({
378 environmentId: selectedProject?.environmentId ?? null,
379 cwd: selectedProject?.workspaceRoot || null,
380 });
381 const knownIsGitRepo = projectGitStatus.data?.isRepo ?? projectBranches.data?.isRepo ?? null;
382 const isGitRepo = knownIsGitRepo ?? true;
383 const projectSettings = projectDefaults.projectSettings;
384 const canChooseWorkspace = !isScratchDraft;
385 const defaultWorkspaceMode: WorkspaceMode = projectDefaults.defaultWorkspaceMode;
386 const branchState = usePaginatedBranches({
387 environmentId: selectedProject?.environmentId ?? null,
388 cwd: selectedProject?.workspaceRoot || null,
389 });
390 const branchesLoading = branchState.isPending && branchState.data === null;
391 const allBranchRefs = branchState.refs;
392 const availableBranches = pipe(
393 allBranchRefs,
394 Arr.filter((branch) => !branch.isRemote),
395 );
396​
397 const resolveWorkspaceSelection = (selection: ComposerDraftWorkspaceSelection | undefined) =>
398 resolveNewTaskDraftWorkspace({
399 selection,
400 canChooseWorkspace,
401 defaultMode: defaultWorkspaceMode,
402 defaultModeSettled: projectDefaults.defaultWorkspaceModeSettled,
403 isGitRepo,
404 branches: allBranchRefs,
405 projectCwd: selectedProject?.workspaceRoot ?? null,
406 });
407 const workspaceSelection = resolveWorkspaceSelection(selectedProjectDraft.workspaceSelection);
408 const workspaceMode = workspaceSelection.mode;
409 const selectedBranchName = workspaceSelection.branch;
410 const selectedWorktreePath = workspaceSelection.worktreePath;
411 // A new worktree does not exist yet, so the project root stands in for it.
412 const workspaceCwd =
413 (workspaceMode === "worktree"
414 ? selectedProject?.workspaceRoot
415 : (selectedWorktreePath ?? selectedProject?.workspaceRoot)) || null;
416 const selectedEnvironmentServerConfig = serverConfigForCwd(
417 projectDefaults.serverConfig,
418 workspaceCwd,
419 );
420 // Keep the user's explicit choice separate from the resolved display value:
421 // only the explicit flag is ever written back to the draft, so the resolved
422 // value keeps tracking the server setting when the config loads late.
423 const draftStartFromOrigin = selectedProjectDraft.workspaceSelection?.startFromOrigin;
424 const startFromOrigin =
425 isGitRepo && (draftStartFromOrigin ?? projectSettings.settings.newWorktreesStartFromOrigin);
426 const defaultRuntimeMode = projectSettings.settings.defaultRuntimeMode;
427 const managedPolicy = selectedEnvironmentServerConfig?.managedPolicy;
428 const runtimeMode = resolveNewThreadRuntimeMode(
429 selectedProjectDraft.runtimeMode,
430 defaultRuntimeMode,
431 managedPolicy,
432 );
433​
434 // Antigravity keeps unavailable selections so sign-out or a catalog change
435 // cannot switch the user's model.
436 const draftModelSelection = resolveSelectableModelSelection(
437 selectedEnvironmentServerConfig,
438 selectedProjectDraft.modelSelection ?? null,
439 selectedProject?.id ?? null,
440 );
441 const projectDefaultModelSelection = resolveDefaultableModelSelection(
442 selectedEnvironmentServerConfig,
443 projectSettings.settings.defaultModelSelection,
444 selectedProject?.id ?? null,
445 );
446 const stickyModelSelection = resolveDefaultableModelSelection(
447 selectedEnvironmentServerConfig,
448 storedStickyModelSelection,
449 selectedProject?.id ?? null,
450 );
451 const modelOptions = buildModelOptions(
452 selectedEnvironmentServerConfig,
453 draftModelSelection ?? projectDefaultModelSelection ?? stickyModelSelection,
454 undefined,
455 selectedProject?.id ?? null,
456 );
457​
458 const selectedDefaultModel = resolveNewTaskModelSelection({
459 draftSelection: draftModelSelection,
460 projectDefaultSelection: projectDefaultModelSelection,
461 stickySelection: stickyModelSelection,
462 modelOptions,
463 });
464 const selectedModel = resolveNewThreadModelSelection({
465 defaultSelection: selectedDefaultModel,
466 explicitSelection:
467 draftModelSelection ?? (projectDefaultModelSelection ? null : stickyModelSelection),
468 fallbackSelection: selectedEnvironmentServerConfig?.settings.fallbackModelSelection ?? null,
469 providers: selectedEnvironmentServerConfig?.providers ?? [],
470 ...(selectedEnvironmentServerConfig
471 ? { settings: selectedEnvironmentServerConfig.settings }
472 : {}),
473 projectId: selectedProject?.id ?? null,
474 now: modelSelectionNow,
475 }).selection;
476 const selectedModelKey = selectedModel
477 ? `${selectedModel.instanceId}:${selectedModel.model}`
478 : null;
479​
480 const selectedModelOption =
481 modelOptions.find(
482 (option) =>
483 selectedModel &&
484 option.selection.instanceId === selectedModel.instanceId &&
485 option.selection.model === selectedModel.model,
486 ) ?? null;
487 const selectedProviderStatus =
488 selectedEnvironmentServerConfig?.providers.find(
489 (provider) => provider.instanceId === selectedModel?.instanceId,
490 ) ?? null;
491 const setSelectedModelKey = (
492 key: string | null,
493 options?: ReadonlyArray<ProviderOptionSelection>,
494 ) => {
495 if (!key || !selectedProjectDraftKey) {
496 return;
497 }
498 const option = modelOptions.find((candidate) => candidate.key === key);
499 if (!option) {
500 return;
501 }
502 const selection = withRememberedModelOptions(
503 options ? { ...option.selection, options } : option.selection,
504 );
505 updateComposerDraftSettings(selectedProjectDraftKey, { modelSelection: selection });
506 setStickyComposerModelSelection(selection);
507 };
508 const setSelectedModelOptions = (options: ReadonlyArray<ProviderOptionSelection> | undefined) => {
509 if (!selectedModel || !selectedProjectDraftKey) {
510 return;
511 }
512 rememberModelOptions(selectedModel.instanceId, selectedModel.model, options ?? []);
513 const nextSelection: ModelSelection = options
514 ? { ...selectedModel, options }
515 : {
516 instanceId: selectedModel.instanceId,
517 model: selectedModel.model,
518 };
519 updateComposerDraftSettings(selectedProjectDraftKey, {
520 modelSelection: nextSelection,
521 });
522 setStickyComposerModelSelection(nextSelection);
523 };
524​
525 const providerGroups = groupByProvider(modelOptions);
526 const setPrompt = (value: string) => {
527 if (!selectedProjectDraftKey) {
528 return;
529 }
530 setComposerDraftText(selectedProjectDraftKey, value);
531 };
532 const replaceAttachments = (nextAttachments: ReadonlyArray<DraftComposerAttachment>) => {
533 if (!selectedProjectDraftKey) {
534 return;
535 }
536 replaceComposerDraftAttachments(selectedProjectDraftKey, nextAttachments);
537 };
538 const appendAttachments = (
539 nextAttachments: ReadonlyArray<DraftComposerAttachment>,
540 insertion?: ComposerDraftInsertion,
541 ): number => {
542 if (!selectedProjectDraftKey) {
543 return 0;
544 }
545 return appendComposerDraftAttachments(selectedProjectDraftKey, nextAttachments, {
546 appendReference: true,
547 insertion,
548 });
549 };
550 const removeAttachment = (imageId: string) => {
551 if (!selectedProjectDraftKey) {
552 return;
553 }
554 removeComposerDraftAttachment(selectedProjectDraftKey, imageId);
555 };
556 const clearAttachments = () => {
557 if (!selectedProjectDraftKey) {
558 return;
559 }
560 replaceComposerDraftAttachments(selectedProjectDraftKey, []);
561 };
562​
563 const carryDraftContentTo = (
564 project: EnvironmentProject,
565 options?: Parameters<typeof retargetNewTaskDraft>[2],
566 ): string => {
567 const target = { environmentId: project.environmentId, projectId: project.id };
568 const current = readFlow().draftKey;
569 if (current !== null && isNewTaskDraftKey(current)) {
570 retargetNewTaskDraft(current, target, options);
571 return current;
572 }
573 return createNewTaskDraft(target);
574 };
575​
576 const setProject = (project: EnvironmentProject) => {
577 updateFlow({
578 draftKey: carryDraftContentTo(project),
579 environmentId: project.environmentId,
580 projectKey: scopedProjectKey(project.environmentId, project.id),
581 });
582 };
583​
584 const selectEnvironment = (environmentId: EnvironmentId) => {
585 const match = resolveEnvironmentProjectMatch(
586 projects.filter((project) => project.environmentId === environmentId),
587 selectedProject,
588 );
589 updateFlow({
590 // A name or title match may be another repository, which must not receive the PR checkout.
591 draftKey: match
592 ? carryDraftContentTo(match, {
593 keepPullRequestWorkspace: isSameRepository(match, selectedProject),
594 })
595 : readFlow().draftKey,
596 environmentId,
597 projectKey: match ? scopedProjectKey(match.environmentId, match.id) : null,
598 });
599 };
600​
601 const openScratch = useAtomCommand(projectEnvironment.openScratch, { reportFailure: false });
602 const prepareTriage = usePrepareTriage();
603 const [switchingToEnvironmentId, setSwitchingToEnvironmentId] = useState<EnvironmentId | null>(
604 null,
605 );
606 const latestSwitchRef = useRef<object | null>(null);
607 const switchEnvironment = async (environmentId: EnvironmentId): Promise<boolean> => {
608 if (environmentId === selectedEnvironmentId) {
609 latestSwitchRef.current = null;
610 setSwitchingToEnvironmentId(null);
611 return true;
612 }
613 if (!isScratchDraft) {
614 selectEnvironment(environmentId);
615 return true;
616 }
617 const request = {};
618 latestSwitchRef.current = request;
619 setSwitchingToEnvironmentId(environmentId);
620 // A triage draft takes its session along: the playbook and context files
621 // exist only on the machine that prepared them.
622 const { draftKey, projectKey } = readFlow();
623 const triage =
624 draftKey !== null && isTriagePrompt(getComposerDraftSnapshot(draftKey).text)
625 ? await prepareTriage(environmentId)
626 : null;
627 const result =
628 triage?._tag === "Failure" ? triage : await openScratch({ environmentId, input: {} });
629 if (latestSwitchRef.current !== request) return false;
630 latestSwitchRef.current = null;
631 setSwitchingToEnvironmentId(null);
632 // A project picked while this waited stands.
633 if (readFlow().projectKey !== projectKey) return false;
634 if (result._tag === "Success") {
635 if (triage?._tag === "Success" && draftKey !== null && readFlow().draftKey === draftKey) {
636 // Read now, so text typed while the machine prepared the session is kept.
637 const text = getComposerDraftSnapshot(draftKey).text;
638 const nextText = replaceTriagePlaybookLink(text, triage.value.prompt);
639 if (nextText !== text) setComposerDraftText(draftKey, nextText);
640 }
641 setProject(result.value);
642 return true;
643 }
644 if (!isAtomCommandInterrupted(result)) {
645 const error = squashAtomCommandFailure(result);
646 Dialog.alert(
647 "Could not switch machine",
648 error instanceof Error
649 ? error.message
650 : triage?._tag === "Failure"
651 ? "The server could not prepare triage."
652 : "The folder for threads without a project could not be created.",
653 );
654 }
655 return false;
656 };
657​
658 const setWorkspaceMode = (mode: WorkspaceMode) => {
659 if (!selectedProjectDraftKey) {
660 return;
661 }
662 if (!selectedProject) {
663 return;
664 }
665 const localSelection = resolveNewTaskLocalWorkspaceSelection({
666 branches: availableBranches,
667 projectCwd: selectedProject.workspaceRoot,
668 });
669 updateComposerDraftSettings(selectedProjectDraftKey, {
670 workspaceSelection: {
671 mode,
672 branch: mode === "local" ? localSelection.branch : selectedBranchName,
673 worktreePath: mode === "local" ? localSelection.worktreePath : selectedWorktreePath,
674 ...(draftStartFromOrigin !== undefined ? { startFromOrigin: draftStartFromOrigin } : {}),
675 // Refs have not named the current branch yet; the selection follows it.
676 ...(mode === "local" && localSelection.awaitsCurrentBranch
677 ? { followsCurrentCheckout: true }
678 : {}),
679 },
680 });
681 };
682​
683 const selectBranch = (branch: VcsRef) => {
684 if (!selectedProject || !selectedProjectDraftKey) {
685 return;
686 }
687 updateComposerDraftSettings(selectedProjectDraftKey, {
688 workspaceSelection: {
689 mode: workspaceMode,
690 branch: branch.name,
691 worktreePath: resolveNewTaskBranchWorktreePath({
692 workspaceMode,
693 projectCwd: selectedProject.workspaceRoot,
694 branchWorktreePath: branch.worktreePath,
695 }),
696 ...(draftStartFromOrigin !== undefined ? { startFromOrigin: draftStartFromOrigin } : {}),
697 },
698 });
699 };
700​
701 const setStartFromOrigin = (value: boolean) => {
702 if (!selectedProjectDraftKey) {
703 return;
704 }
705 updateComposerDraftSettings(selectedProjectDraftKey, {
706 workspaceSelection: {
707 mode: workspaceMode,
708 branch: selectedBranchName,
709 worktreePath: selectedWorktreePath,
710 startFromOrigin: value,
711 ...(selectedBranchName === null && workspaceSelection.followsCurrentCheckout
712 ? { followsCurrentCheckout: true }
713 : {}),
714 },
715 });
716 };
717​
718 const refreshBranches = branchState.refresh;
719 const loadBranches = () => {
720 if (!selectedProject) {
721 return;
722 }
723 setPendingConnectionError(null);
724 refreshBranches();
725 };
726​
727 const setRuntimeMode = (value: RuntimeMode) => {
728 if (selectedProjectDraftKey) {
729 updateComposerDraftSettings(selectedProjectDraftKey, { runtimeMode: value });
730 }
731 };
732​
733 const buildPendingTaskMessage = (
734 metadata: TurnCommandMetadata,
735 options?: { readonly currentCheckoutBranch?: string | null },
736 ): QueuedThreadMessage | null => {
737 if (!selectedProject || !selectedProjectDraftKey) {
738 return null;
739 }
740 const draft = getComposerDraftSnapshot(selectedProjectDraftKey);
741 const text = draft.text.trim();
742 const draftModelSelection =
743 resolveSelectableModelSelection(
744 selectedEnvironmentServerConfig,
745 draft.modelSelection ?? null,
746 selectedProject.id,
747 ) ?? selectedModel;
748 if ((text.length === 0 && draft.attachments.length === 0) || !draftModelSelection) {
749 return null;
750 }
751 if (
752 threadContextsOutsideEnvironment({
753 text: draft.text,
754 records: draft.context?.records ?? [],
755 environmentId: selectedProject.environmentId,
756 linkedEnvironments,
757 }).length > 0
758 ) {
759 return null;
760 }
761 const workspaceSelection = resolveWorkspaceSelection(draft.workspaceSelection);
762 const mode = workspaceSelection.mode;
763 return {
764 environmentId: selectedProject.environmentId,
765 threadId: ThreadId.make(metadata.threadId),
766 messageId: MessageId.make(metadata.messageId),
767 commandId: CommandId.make(metadata.commandId),
768 text,
769 attachments: draft.attachments,
770 context: draft.context,
771 modelSelection: draftModelSelection,
772 runtimeMode: resolveNewThreadRuntimeMode(
773 draft.runtimeMode,
774 defaultRuntimeMode,
775 managedPolicy,
776 ),
777 interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
778 creation: {
779 projectId: selectedProject.id,
780 projectTitle: selectedProject.title,
781 projectCwd: selectedProject.workspaceRoot,
782 workspaceMode: mode,
783 ...(mode === "worktree" && workspaceSelection?.pullRequestReference
784 ? { pullRequestReference: workspaceSelection.pullRequestReference }
785 : {}),
786 // Queued local tasks use drain-time checkout; snapshot branches only for immediate sends or explicit choices.
787 branch: resolveProjectThreadCreationBranch({
788 workspaceMode: mode,
789 selectedBranch: workspaceSelection?.branch ?? null,
790 currentCheckoutBranch: options?.currentCheckoutBranch ?? null,
791 }),
792 worktreePath: mode === "worktree" ? null : (workspaceSelection?.worktreePath ?? null),
793 ...((workspaceSelection?.startFromOrigin ?? startFromOrigin)
794 ? { startFromOrigin: true }
795 : {}),
796 },
797 createdAt: metadata.createdAt,
798 };
799 };
800​
801 const scratchEnvironments = connectedEnvironments.filter(
802 (environment) =>
803 availableScratchWorkspaceRoot(
804 environment.connectionState,
805 serverConfigs.get(environment.environmentId),
806 ) !== null,
807 );
808​
809 const selectedRepositoryKey = selectedProject?.repositoryIdentity
810 ? repositoryGroupingKeyOf(selectedProject.repositoryIdentity)
811 : null;
812 // Use || null: placeholder workspaceRoot can be empty, and an empty basename rejects real hosts.
813 const selectedWorkspaceBasename = selectedProject?.workspaceRoot.split("/").at(-1) || null;
814 const selectedProjectTitle = selectedProject?.title ?? null;
815 const environments = (() => {
816 if (isScratchDraft) {
817 return scratchEnvironments.map((environment) => ({
818 environmentId: environment.environmentId,
819 environmentLabel: environment.environmentLabel,
820 }));
821 }
822 const seen = new Set<EnvironmentId>();
823 const result: Array<{
824 readonly environmentId: EnvironmentId;
825 readonly environmentLabel: string;
826 }> = [];
827 const hostsSelectedRepository = (project: EnvironmentProject) => {
828 if (selectedRepositoryKey === null && selectedWorkspaceBasename === null) {
829 return true;
830 }
831 const projectKey = project.repositoryIdentity
832 ? repositoryGroupingKeyOf(project.repositoryIdentity)
833 : null;
834 if (selectedRepositoryKey !== null && projectKey !== null) {
835 return projectKey === selectedRepositoryKey;
836 }
837 return (
838 project.workspaceRoot.split("/").at(-1) === selectedWorkspaceBasename ||
839 (selectedProjectTitle !== null && project.title === selectedProjectTitle)
840 );
841 };
842 for (const project of projects) {
843 if (!hostsSelectedRepository(project)) {
844 continue;
845 }
846 if (seen.has(project.environmentId)) {
847 continue;
848 }
849 const environment = savedConnectionsById[project.environmentId];
850 if (!environment) {
851 continue;
852 }
853 seen.add(project.environmentId);
854 result.push({
855 environmentId: project.environmentId,
856 environmentLabel: environment.environmentLabel,
857 });
858 }
859 return result;
860 })();
861​
862 const value = {
863 activeNewTask,
864 projectScopes,
865 selectedEnvironmentId,
866 selectedProjectKey,
867 selectedModelKey,
868 workspaceMode,
869 isGitRepo,
870 isGitRepoKnown: knownIsGitRepo !== null,
871 canChooseWorkspace,
872 selectedBranchName,
873 selectedWorktreePath,
874 workspaceCwd,
875 resolveWorkspaceSelection,
876 startFromOrigin,
877 draftKey: selectedProjectDraftKey,
878 pullRequestReference: selectedProjectDraft.workspaceSelection?.pullRequestReference,
879 prompt,
880 attachments,
881 submitting,
882 branchesLoading,
883 availableBranches,
884 currentCheckoutBranchName,
885 runtimeMode,
886 expandedProvider,
887 environments,
888 selectedProject,
889 linkedEnvironments,
890 isScratchDraft,
891 modelOptions,
892 selectedModel,
893 selectedModelOption,
894 selectedProviderStatus,
895 providerGroups,
896 setProject,
897 getSelectedProjectKey: () => readFlow().projectKey,
898 unopenableRouteDraft:
899 props.routeDraftId !== undefined &&
900 (routeDraftResolution.kind === "missing" || routeDraftResolution.kind === "pickProject")
901 ? { draftId: props.routeDraftId, kind: routeDraftResolution.kind }
902 : null,
903 selectEnvironment,
904 switchEnvironment,
905 switchingToEnvironmentId,
906 setSelectedModelKey,
907 setWorkspaceMode,
908 selectBranch,
909 setStartFromOrigin,
910 buildPendingTaskMessage,
911 setPrompt,
912 replaceAttachments,
913 appendAttachments,
914 removeAttachment,
915 clearAttachments,
916 setSubmitting: (value: boolean) => {
917 // A send takes the draft as it is, so a machine switch still waiting is dropped.
918 if (value) {
919 latestSwitchRef.current = null;
920 setSwitchingToEnvironmentId(null);
921 }
922 updateFlow({ submitting: value });
923 },
924 loadBranches,
925 setRuntimeMode,
926 setSelectedModelOptions,
927 setExpandedProvider: (value: string | null) => updateFlow({ expandedProvider: value }),
928 } satisfies NewTaskFlowContextValue;
929​
930 return (
931 <ActiveNewTaskContext value={activeNewTask}>
932 <NewTaskFlowContext.Provider value={value}>{props.children}</NewTaskFlowContext.Provider>
933 </ActiveNewTaskContext>
934 );
936​
937export function useNewTaskFlow() {
938 const value = React.use(NewTaskFlowContext);
939 if (value === null) {
940 throw new Error("useNewTaskFlow must be used within NewTaskFlowProvider.");
941 }
942 return value;