@devries-cameron20 / t3code Mirror · read-only / commits / dc102e5062
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 22, 08:15 UTC

fix(web): skill menus show loading while project skills arrive (#28209)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

NotAnNvidiaFan committed Oct 31, 2026 at 21:47 UTC dc102e5062fd3ac87abaa146b24771e82e4d7f37
6 files changed +106 -19
apps/web/src/components/chat/ChatComposer.tsx
+10 -6
@@ -934,11 +934,12 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
934 const selectedProviderSlashCommands = selectedProviderStatus
935 ? resolveProviderSlashCommandsForCwd(selectedProviderStatus, gitCwd)
936 : NO_PROVIDER_SLASH_COMMANDS;
937 - const refreshWorkspaceSnapshotOnTyping = useProviderWorkspaceSnapshotRefresh({
938 - environmentId,
939 - gitCwd,
940 - instanceId: selectedProviderEntry?.instanceId,
941 - });
937 + const { refresh: refreshWorkspaceSnapshotOnTyping, scanning: workspaceSkillsScanning } =
938 + useProviderWorkspaceSnapshotRefresh({
939 + environmentId,
940 + gitCwd,
941 + instanceId: selectedProviderEntry?.instanceId,
942 + });
943
944 const selectedPromptEffort = composerProviderState.promptEffort;
945 const selectedModelOptionsForDispatch = composerProviderState.modelOptionsForDispatch;
@@ -1139,6 +1140,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
1140 selectedProviderSkills,
1141 selectedProviderSlashCommands,
1142 showSkillsInSlashMenu: settings.showSkillsInSlashMenu,
1143 + workspaceSkillsScanning,
1144 questionAttachmentTarget,
1145 });
1146
@@ -3289,7 +3291,9 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
3291 ? isComposerMenuLoading
3292 ? composerTriggerKind === "pull-request"
3293 ? "Finding pull request..."
3292 - : "Searching workspace files..."
3294 + : composerTriggerKind === "skill" || composerTriggerKind === "slash-command"
3295 + ? "Searching workspace skills..."
3296 + : "Searching workspace files..."
3297 : composerMenuEmptyState
3298 : ""}
3299 </div>
apps/web/src/components/chat/ComposerCommandMenu.tsx
+1 -1
@@ -152,7 +152,7 @@ export const ComposerCommandMenu = memo(function ComposerCommandMenu(props: {
152 <div className="px-5 pt-3.5 pb-7">
153 <p className="text-secondary-label text-xs">
154 {props.isLoading
155 - ? props.triggerKind === "skill"
155 + ? props.triggerKind === "skill" || props.triggerKind === "slash-command"
156 ? "Searching workspace skills..."
157 : props.triggerKind === "pull-request"
158 ? "Finding pull request..."
apps/web/src/components/chat/useComposerMenuItems.ts
+4
@@ -71,6 +71,7 @@ export function useComposerMenuItems({
71 selectedProviderSkills,
72 selectedProviderSlashCommands,
73 showSkillsInSlashMenu,
74 + workspaceSkillsScanning,
75 questionAttachmentTarget,
76 }: {
77 readonly composerTrigger: ComposerTrigger | null;
@@ -89,6 +90,7 @@ export function useComposerMenuItems({
90 readonly selectedProviderSkills: ServerProvider["skills"];
91 readonly selectedProviderSlashCommands: ServerProvider["slashCommands"];
92 readonly showSkillsInSlashMenu: boolean;
93 + readonly workspaceSkillsScanning: boolean;
94 readonly questionAttachmentTarget: DraftId | null;
95 }) {
96 // Thread mentions rank by recency as of when the composer mounted.
@@ -373,6 +375,8 @@ export function useComposerMenuItems({
375 })();
376 const isLoading =
377 (composerTriggerKind === "path" && pathTriggerQuery.length > 0 && workspaceEntries.isPending) ||
378 + ((composerTriggerKind === "skill" || composerTriggerKind === "slash-command") &&
379 + workspaceSkillsScanning) ||
380 (composerTriggerKind === "pull-request" &&
381 pullRequestProjectId !== null &&
382 pullRequestRepository !== null &&
apps/web/src/components/chat/useProviderWorkspaceSnapshotRefresh.ts
+16 -8
@@ -1,6 +1,10 @@
1 -import { useAtomRefresh } from "@effect/atom-react";
1 +import { useAtomRefresh, useAtomValue } from "@effect/atom-react";
2 import { type EnvironmentId, type ProviderInstanceId } from "@t3tools/contracts";
3 -import { createProviderWorkspaceSnapshotRefreshAtomFamily } from "@t3tools/client-runtime/providerSkills";
3 +import {
4 + createProviderWorkspaceSnapshotRefreshAtomFamily,
5 + isProviderWorkspaceSnapshotScanning,
6 + type ProviderWorkspaceSnapshotRefreshState,
7 +} from "@t3tools/client-runtime/providerSkills";
8 import { Atom } from "effect/reactivity";
9
10 import { serverEnvironment } from "../../state/server";
@@ -10,23 +14,27 @@ const providerWorkspaceSnapshotRefresh = createProviderWorkspaceSnapshotRefreshA
14 refreshProviders: serverEnvironment.refreshProviders,
15 });
16
13 -const idleRefreshAtom: Atom.Atom<unknown> = Atom.make<void>(undefined).pipe(
14 - Atom.withLabel("provider-workspace-snapshot-refresh:idle"),
15 -);
17 +const idleRefreshAtom: Atom.Atom<ProviderWorkspaceSnapshotRefreshState | undefined> = Atom.make<
18 + ProviderWorkspaceSnapshotRefreshState | undefined
19 +>(undefined).pipe(Atom.withLabel("provider-workspace-snapshot-refresh:idle"));
20
21 /**
22 * Keeps the selected provider's workspace snapshot fresh for the composer's
19 - * cwd while mounted. Returns a check to run when the user types.
23 + * cwd while mounted. Returns a check to run when the user types, and whether
24 + * the cwd's skills are still being scanned.
25 */
26 export function useProviderWorkspaceSnapshotRefresh(input: {
27 readonly environmentId: EnvironmentId;
28 readonly gitCwd: string | null;
29 readonly instanceId: ProviderInstanceId | undefined;
25 -}): () => void {
30 +}): { readonly refresh: () => void; readonly scanning: boolean } {
31 const { environmentId, gitCwd, instanceId } = input;
32 const atom =
33 gitCwd && instanceId
34 ? providerWorkspaceSnapshotRefresh({ environmentId, instanceId, cwd: gitCwd })
35 : idleRefreshAtom;
31 - return useAtomRefresh(atom);
36 + return {
37 + refresh: useAtomRefresh(atom),
38 + scanning: isProviderWorkspaceSnapshotScanning(useAtomValue(atom)),
39 + };
40 }
packages/client-runtime/src/providerSkills.test.ts
+48
@@ -12,6 +12,7 @@ import {
12 createProviderWorkspaceSnapshotRefreshAtomFamily,
13 getProviderSkillsForSlashMenu,
14 hasCompleteProviderWorkspaceSnapshot,
15 + isProviderWorkspaceSnapshotScanning,
16 resolveProviderSkillsForCwd,
17 resolveProviderSlashCommandsForCwd,
18 } from "./providerSkills.ts";
@@ -298,6 +299,53 @@ describe("provider workspace snapshot refresh atom", () => {
299 unmount();
300 });
301
302 + it("reports skills loading while a missing snapshot is scanned, until it arrives", async () => {
303 + vi.useFakeTimers({ now: Date.parse("2026-01-01T00:00:00.000Z") });
304 + const scanned = withSnapshot("2026-01-01T00:00:00.000Z");
305 + const { registry, atom, providersAtom, unmount } = setup(noSnapshot, [() => scanned]);
306 + expect(isProviderWorkspaceSnapshotScanning(registry.get(atom))).toBe(true);
307 + registry.set(providersAtom, scanned);
308 + await vi.advanceTimersByTimeAsync(0);
309 + expect(isProviderWorkspaceSnapshotScanning(registry.get(atom))).toBe(false);
310 + unmount();
311 + });
312 +
313 + it("stops reporting skills loading when the scan fails", async () => {
314 + vi.useFakeTimers({ now: Date.parse("2026-01-01T00:00:00.000Z") });
315 + const { registry, atom, unmount } = setup(noSnapshot);
316 + expect(isProviderWorkspaceSnapshotScanning(registry.get(atom))).toBe(true);
317 + await vi.advanceTimersByTimeAsync(0);
318 + expect(isProviderWorkspaceSnapshotScanning(registry.get(atom))).toBe(false);
319 + unmount();
320 + });
321 +
322 + it("keeps reporting skills loading while the scan returns a pending snapshot", async () => {
323 + vi.useFakeTimers({ now: Date.parse("2026-01-01T00:00:00.000Z") });
324 + const pending = withSnapshot("2026-01-01T00:00:00.000Z", true);
325 + const { registry, atom, providersAtom, unmount } = setup(pending, [() => pending]);
326 + await vi.advanceTimersByTimeAsync(0);
327 + expect(isProviderWorkspaceSnapshotScanning(registry.get(atom))).toBe(true);
328 + registry.set(providersAtom, withSnapshot("2026-01-01T00:00:00.000Z"));
329 + expect(isProviderWorkspaceSnapshotScanning(registry.get(atom))).toBe(false);
330 + unmount();
331 + });
332 +
333 + it("stops reporting skills loading once a pending snapshot exhausts its retries", async () => {
334 + vi.useFakeTimers({ now: Date.parse("2026-01-01T00:00:00.000Z") });
335 + const { registry, atom, run, unmount } = setup(withSnapshot("2026-01-01T00:00:00.000Z", true));
336 + await vi.advanceTimersByTimeAsync(60_000);
337 + expect(run).toHaveBeenCalledTimes(3);
338 + expect(isProviderWorkspaceSnapshotScanning(registry.get(atom))).toBe(false);
339 + unmount();
340 + });
341 +
342 + it("does not report skills loading for a current snapshot", () => {
343 + vi.useFakeTimers({ now: Date.parse("2026-01-01T00:01:00.000Z") });
344 + const { registry, atom, unmount } = setup(withSnapshot("2026-01-01T00:00:00.000Z"));
345 + expect(isProviderWorkspaceSnapshotScanning(registry.get(atom))).toBe(false);
346 + unmount();
347 + });
348 +
349 it("does not retry on a timer when the failed scan left no pending snapshot", async () => {
350 vi.useFakeTimers({ now: Date.parse("2026-01-01T00:00:00.000Z") });
351 const { registry, atom, run, unmount } = setup(noSnapshot);
packages/client-runtime/src/providerSkills.ts
+27 -4
@@ -136,7 +136,7 @@ const WORKSPACE_SNAPSHOT_RETRY_COOLDOWN_MS = 10_000;
136 // A cwd that never scans, such as a deleted worktree, would otherwise retry forever.
137 const WORKSPACE_SNAPSHOT_MAX_ATTEMPTS = 3;
138
139 -interface ProviderWorkspaceSnapshotRefreshState {
139 +export interface ProviderWorkspaceSnapshotRefreshState {
140 /**
141 * When the last scan was requested. A request inside the TTL is not
142 * repeated, so a client clock ahead of the server's cannot loop rescans.
@@ -147,6 +147,8 @@ interface ProviderWorkspaceSnapshotRefreshState {
147 /** Failed scans within the current request TTL. */
148 readonly failedAttempts: number;
149 readonly hadSnapshot: boolean;
150 + /** The server published a partial snapshot and is still discovering. */
151 + readonly snapshotPending: boolean;
152 }
153
154 const initialProviderWorkspaceSnapshotRefreshState: ProviderWorkspaceSnapshotRefreshState = {
@@ -154,6 +156,7 @@ const initialProviderWorkspaceSnapshotRefreshState: ProviderWorkspaceSnapshotRef
156 retryNotBefore: null,
157 failedAttempts: 0,
158 hadSnapshot: false,
159 + snapshotPending: false,
160 };
161
162 /**
@@ -172,6 +175,8 @@ function planProviderWorkspaceSnapshotRefresh(
175 readonly recheckAt: number | null;
176 } {
177 const hasSnapshot = hasCompleteProviderWorkspaceSnapshot(provider, cwd);
178 + const pending =
179 + (provider && resolveProviderWorkspaceSnapshot(provider, cwd)?.slashCommandsPending) === true;
180 // Losing a snapshot (the server dropped it) lifts both the TTL and the retry
181 // cooldown so the scan happens at once.
182 const lost = previous.hadSnapshot && !hasSnapshot;
@@ -188,6 +193,7 @@ function planProviderWorkspaceSnapshotRefresh(
193 ? 0
194 : previous.failedAttempts,
195 hadSnapshot: hasSnapshot,
196 + snapshotPending: pending,
197 };
198 const refresh =
199 (requestedAt === null || now - requestedAt >= PROVIDER_WORKSPACE_SNAPSHOT_TTL_MS) &&
@@ -196,8 +202,6 @@ function planProviderWorkspaceSnapshotRefresh(
202 if (refresh) {
203 return { state: { ...state, requestedAt: now }, refresh: true, recheckAt: null };
204 }
199 - const pending =
200 - (provider && resolveProviderWorkspaceSnapshot(provider, cwd)?.slashCommandsPending) === true;
205 return { state, refresh: false, recheckAt: pending ? retryNotBefore : null };
206 }
207
@@ -223,6 +227,23 @@ function failProviderWorkspaceSnapshotRefresh(
227 };
228 }
229
230 +/**
231 + * A scan is in flight, or the server is still discovering, for a cwd without a
232 + * complete snapshot, so its skills and commands may still arrive. A failed scan
233 + * clears `requestedAt`, and exhausted attempts end it, so this cannot stay true
234 + * for a scan that will not finish.
235 + */
236 +export function isProviderWorkspaceSnapshotScanning(
237 + state: ProviderWorkspaceSnapshotRefreshState | undefined,
238 +): boolean {
239 + return (
240 + state !== undefined &&
241 + (state.requestedAt !== null || state.snapshotPending) &&
242 + !state.hadSnapshot &&
243 + state.failedAttempts < WORKSPACE_SNAPSHOT_MAX_ATTEMPTS
244 + );
245 +}
246 +
247 type WorkspaceSnapshotStatus = "absent" | "pending" | "complete";
248
249 function resolveWorkspaceSnapshotStatus(
@@ -330,6 +351,8 @@ export function createProviderWorkspaceSnapshotRefreshAtomFamily(input: {
351 ).pipe(Atom.withLabel(`provider-workspace-snapshot-refresh:${key}`));
352 return refreshAtom;
353 });
333 - return (target: ProviderWorkspaceSnapshotRefreshTarget): Atom.Atom<unknown> =>
354 + return (
355 + target: ProviderWorkspaceSnapshotRefreshTarget,
356 + ): Atom.Atom<ProviderWorkspaceSnapshotRefreshState> =>
357 family({ environmentId: target.environmentId, instanceId: target.instanceId, cwd: target.cwd });
358 }