@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, 04:45 UTC

main
ts 207 lines 7.99 KB
Raw
1 import { errorDisplayMessage } from "@t3tools/client-runtime/errors";
2 import { useAtomValue } from "@effect/atom-react";
3 import { visibleLinkedThreads } from "@t3tools/client-runtime/state/threads";
4 import { AsyncResult } from "effect/reactivity";
5 import { useGT } from "gt-react-native";
6 import { settlePromise, squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
7 import * as Dialog from "../../components/ui/Dialog";
8 import {
9 StackActions,
10 useNavigation,
11 useNavigationState,
12 useRoute,
13 } from "@react-navigation/native";
14 import { threadPullRequestLinkMode } from "@t3tools/client-runtime/thread-pull-request-compatibility";
15 import {
16 AuthOrchestrationOperateScope,
17 AuthSourceControlWriteScope,
18 ThreadId,
19 type PullRequestDetail,
20 type PullRequestLinkedThreadsResult,
21 } from "@t3tools/contracts";
22 import { formatComposerContextReference } from "@t3tools/shared/composerContextReferences";
23 import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients";
24 import { changeRequestTermKind } from "../../lib/changeRequestTerm";
25 import { normalizeThreadPullRequestKey } from "@t3tools/client-runtime/thread-pull-requests";
26 import { useRef, useState } from "react";
27 import { pullRequestComposerContext } from "../../lib/composerContext";
28 import { scopedThreadKey } from "../../lib/scopedEntities";
29 import { uuidv4 } from "../../lib/uuid";
30 import { useEnvironmentServerConfig } from "../../state/entities";
31 import { composerPullRequests } from "../../state/pull-requests";
32 import { useEnvironmentQuery } from "../../state/query";
33 import { environmentThreadShells } from "../../state/threads";
34 import { useEnvironmentScope } from "../../state/session";
35 import {
36 createNewTaskDraft,
37 getComposerDraftSnapshot,
38 insertComposerDraftContext,
39 setComposerDraftText,
40 updateComposerDraftSettings,
41 waitForComposerDraftsLoaded,
42 } from "../../state/use-composer-drafts";
43 import { usePullRequestConnected } from "./usePullRequestConnected";
44 import { pullRequestTarget, type PullRequestParams } from "./usePullRequestDiff";
45 import {
46 appendPullRequestAgentPrompt,
47 pullRequestAgentPrompt,
48 type PullRequestAgentTask,
49 } from "./pullRequestAgentTasks";
50 import { m } from "../../i18n/messages";
51
52 type LinkedThread = PullRequestLinkedThreadsResult["threads"][number];
53
54 export function usePullRequestThreads(
55 params: PullRequestParams,
56 pr: PullRequestDetail | null,
57 filePath?: string,
58 ) {
59 const target = pullRequestTarget(params);
60 const config = useEnvironmentServerConfig(target.environmentId);
61 const supported = threadPullRequestLinkMode(config?.environment.capabilities) === "multiple";
62 const parsed = pr ? sourceControlClients.parseChangeRequestUrl(pr.url)?.link : undefined;
63 const reference = {
64 ...target,
65 input: { ...target.input, ...(parsed ? normalizeThreadPullRequestKey(parsed) : {}) },
66 };
67 const key = JSON.stringify(reference);
68 const route = useRoute();
69 // The iOS synthetic workspace parent's focus differs from the visible detail's focus.
70 const focused = useNavigationState((state) => state.routes[state.index]?.key === route.key);
71 const relations = useEnvironmentQuery(
72 pr && supported && focused ? composerPullRequests.linkedThreads(reference) : null,
73 );
74 const [lastRelations, setLastRelations] = useState({ key, data: relations.data });
75 if (relations.data && (lastRelations.key !== key || relations.data !== lastRelations.data))
76 setLastRelations({ key, data: relations.data });
77 const hiddenKeys = useAtomValue(environmentThreadShells.hiddenThreadKeysAtom);
78 const hidingAnywhere = useAtomValue(environmentThreadShells.anyEnvironmentHidingAtom);
79 const loadedThreadRefs = useAtomValue(
80 environmentThreadShells.environmentThreadRefsAtom(target.environmentId),
81 );
82 const threads = visibleLinkedThreads(
83 (relations.data ?? (lastRelations.key === key ? lastRelations.data : null))?.threads ?? [],
84 target.environmentId,
85 loadedThreadRefs,
86 hiddenKeys,
87 hidingAnywhere,
88 );
89 const connected = usePullRequestConnected(params.environmentId);
90 const canOperate = useEnvironmentScope(target.environmentId, AuthOrchestrationOperateScope);
91 const canAsk = !connected || canOperate;
92 const canCheckout = useEnvironmentScope(target.environmentId, AuthSourceControlWriteScope);
93 const navigation = useNavigation();
94 const gt = useGT();
95 const pending = useRef(false);
96 const previousPrompts = useRef(new Map<string, string>());
97 const openThread = (thread: LinkedThread) => {
98 openThreadRoute({ environmentId: params.environmentId, threadId: thread.id });
99 };
100 const openThreadRoute = (destination: ReactNavigation.RootParamList["Thread"]) => {
101 navigation.dispatch(StackActions.push("Thread", destination));
102 };
103 const [busy, setBusy] = useState(false);
104 const ask = async (thread?: LinkedThread, task: PullRequestAgentTask = "ask") => {
105 if (!pr || !canAsk || pending.current) return;
106 const terminology = sourceControlClients.get(pr.provider).changeRequest;
107 pending.current = true;
108 setBusy(true);
109 const result = await settlePromise(async () => {
110 if (connected && !thread && !canCheckout)
111 throw new Error(
112 gt(
113 "Starting work from this {term, select, mr {MR} cr {change request} other {PR}} requires source control write access.",
114 {
115 term: changeRequestTermKind(terminology),
116 },
117 ),
118 );
119 await waitForComposerDraftsLoaded();
120 const draftKey = thread
121 ? scopedThreadKey(target.environmentId, ThreadId.make(thread.id))
122 : createNewTaskDraft({
123 environmentId: target.environmentId,
124 projectId: target.input.projectId,
125 });
126 if (!thread)
127 updateComposerDraftSettings(draftKey, {
128 workspaceSelection: {
129 mode: "worktree",
130 branch: pr.headBranch,
131 worktreePath: null,
132 startFromOrigin: false,
133 pullRequestReference: pr.url,
134 },
135 });
136 const context = pullRequestComposerContext(
137 {
138 number: pr.number,
139 title: pr.title,
140 url: pr.url,
141 headBranch: pr.headBranch,
142 baseBranch: pr.baseBranch,
143 state: pr.state,
144 isDraft: pr.isDraft,
145 },
146 uuidv4(),
147 filePath,
148 );
149 const draft = getComposerDraftSnapshot(draftKey);
150 const attached = draft.context?.records.some(
151 (record) =>
152 record.kind === "review-comment" &&
153 "pullRequest" in record &&
154 record.pullRequest?.url === pr.url &&
155 record.filePath === context.filePath,
156 );
157 if (
158 !attached &&
159 !insertComposerDraftContext(
160 draftKey,
161 {
162 text: `${formatComposerContextReference(context)} `,
163 context: { version: 1, records: [context] },
164 },
165 { text: draft.text, start: draft.text.length, end: draft.text.length },
166 )
167 )
168 throw new Error(gt("Remove some context from this thread's draft, then try again."));
169 const withContext = getComposerDraftSnapshot(draftKey);
170 setComposerDraftText(
171 draftKey,
172 appendPullRequestAgentPrompt(
173 withContext.text,
174 task,
175 terminology,
176 previousPrompts.current.get(draftKey),
177 ),
178 );
179 previousPrompts.current.set(draftKey, pullRequestAgentPrompt(task, terminology));
180 if (thread) openThread(thread);
181 else
182 openThreadRoute({
183 draft: { draftId: draftKey, title: gt("Ask about #{number}", { number: pr.number }) },
184 });
185 });
186 pending.current = false;
187 setBusy(false);
188 if (AsyncResult.isFailure(result)) {
189 const cause = squashAtomCommandFailure(result);
190 Dialog.alert(
191 gt("Couldn't open a thread"),
192 cause instanceof Error
193 ? (errorDisplayMessage(cause, m) ?? cause.message)
194 : gt("Try again."),
195 );
196 }
197 };
198 return {
199 ...relations,
200 threads,
201 canAsk,
202 canWatch: config?.environment.capabilities.threadPullRequestWatch === true,
203 busy,
204 ask,
205 openThread,
206 };
207 }