import { keepPreviousData, useMutation, useQuery, useQueryClient, } from "@tanstack/react-query"; import { deleteBuiltinSkill, deleteCustomSkill, deleteSkillFile, duplicateSkill, enableSkill, generateMissingSkillNameZh, generateSkillNameZh, getSkill, getSkillContent, getSkillFileContent, getSkillFiles, installSkillUpload, reconcileCustomSkills, saveSkillFile, setSkillAlwaysOn, setSkillDetail, setSkillNameZh, setSkillDisplay, setSkillPinned, setSkillFeatured, setSkillPublished, setSkillState, validateSkillUpload, } from "./api"; import type { ListSkillsParams } from "./api"; import type { Skill, SkillState } from "./type"; import { loadAllSkillsAdmin, loadSkills } from "."; // Stable empty fallback. Returning `data ?? []` inline would hand out a fresh // array reference on every render while the query is loading/errored, which // makes downstream `useMemo([skills])` / `useEffect([skills])` consumers churn // forever (observed as a "Maximum update depth exceeded" loop on NewAgentPage). const EMPTY_SKILLS: Skill[] = []; export function useSkills(params: ListSkillsParams = {}) { const search = params.search ?? ""; const tagIds = params.tagIds ?? []; const sort = params.sort ?? "time_desc"; const scope = params.scope; const { data, isLoading, error } = useQuery({ queryKey: ["skills", search, [...tagIds].sort(), sort, scope ?? "all"], queryFn: () => loadSkills({ search, tagIds, sort, scope }), placeholderData: keepPreviousData, }); return { skills: data ?? EMPTY_SKILLS, isLoading, error }; } /** * Admin-only listing — every skill in the system (built-in + every user's * custom skills, including unpublished ones owned by other users). Backend * 403s if the caller is not ``system_role === "admin"``. */ export function useAllSkillsAdmin(enabled: boolean) { const { data, isLoading, error } = useQuery({ queryKey: ["skills", "admin", "all"], queryFn: () => loadAllSkillsAdmin(), enabled, staleTime: 30_000, }); return { skills: data ?? EMPTY_SKILLS, isLoading, error }; } export function useSkillContent(skillName: string | null) { return useQuery({ queryKey: ["skill-content", skillName], queryFn: () => getSkillContent(skillName!), enabled: !!skillName, }); } export function useSkill(skillName: string | null) { return useQuery({ queryKey: ["skill", skillName], queryFn: () => getSkill(skillName!), enabled: !!skillName, }); } export function useSetSkillDetail() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ skillName, detail }: { skillName: string; detail: string }) => setSkillDetail(skillName, detail), onSuccess: (_data, { skillName }) => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); void queryClient.invalidateQueries({ queryKey: ["skill", skillName] }); }, }); } export function useSetSkillNameZh() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ skillName, nameZh }: { skillName: string; nameZh: string }) => setSkillNameZh(skillName, nameZh), onSuccess: (_data, { skillName }) => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); void queryClient.invalidateQueries({ queryKey: ["skill", skillName] }); }, }); } export function useGenerateSkillNameZh() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ skillName, modelName }: { skillName: string; modelName?: string | null }) => generateSkillNameZh(skillName, modelName), onSuccess: (_data, { skillName }) => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); void queryClient.invalidateQueries({ queryKey: ["skill", skillName] }); }, }); } export function useGenerateMissingSkillNameZh() { const queryClient = useQueryClient(); return useMutation({ mutationFn: (modelName?: string | null) => generateMissingSkillNameZh(modelName), onSuccess: () => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); }, }); } export function useSetSkillDisplay() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ skillName, display, sample, }: { skillName: string; display: Parameters[1]; sample?: Parameters[2]; }) => setSkillDisplay(skillName, display, sample), onSuccess: (data, { skillName }) => { queryClient.setQueryData(["skill", skillName], data); queryClient.setQueriesData({ queryKey: ["skills"] }, (current) => Array.isArray(current) ? current.map((item) => (item.name === skillName ? { ...item, ...data } : item)) : current, ); void queryClient.invalidateQueries({ queryKey: ["skills"] }); void queryClient.invalidateQueries({ queryKey: ["skill", skillName] }); }, }); } export function useEnableSkill() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ skillName, enabled, }: { skillName: string; enabled: boolean; }) => enableSkill(skillName, enabled), onSuccess: (data, { skillName }) => { // The availability endpoint intentionally returns the filesystem skill // without ownership/tag annotations. Patch only the authoritative flag // so a fast cache update cannot erase richer list/detail metadata. queryClient.setQueryData(["skill", skillName], (current) => current ? { ...current, enabled: data.enabled } : current, ); queryClient.setQueriesData({ queryKey: ["skills"] }, (current) => Array.isArray(current) ? current.map((item) => item.name === skillName ? { ...item, enabled: data.enabled } : item, ) : current, ); void queryClient.invalidateQueries({ queryKey: ["skills"] }); void queryClient.invalidateQueries({ queryKey: ["skill", skillName] }); }, }); } export function useSetSkillAlwaysOn() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ skillName, alwaysOn }: { skillName: string; alwaysOn: boolean }) => setSkillAlwaysOn(skillName, alwaysOn), onSuccess: (data, { skillName }) => { queryClient.setQueryData(["skill", skillName], data); queryClient.setQueriesData({ queryKey: ["skills"] }, (current) => Array.isArray(current) ? current.map((item) => (item.name === skillName ? { ...item, ...data } : item)) : current, ); void queryClient.invalidateQueries({ queryKey: ["skills"] }); void queryClient.invalidateQueries({ queryKey: ["skill", skillName] }); }, }); } export function useValidateSkillUpload() { return useMutation({ mutationFn: ({ file, targetCategory, }: { file: File; targetCategory?: "public" | "custom"; }) => validateSkillUpload(file, targetCategory), }); } export function useInstallSkillUpload() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ file, overwrite, targetCategory }: { file: File; overwrite?: boolean; targetCategory?: "public" | "custom" }) => installSkillUpload(file, { overwrite, targetCategory }), onSuccess: () => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); }, }); } export function useReconcileCustomSkills() { const queryClient = useQueryClient(); return useMutation({ mutationFn: () => reconcileCustomSkills(), onSuccess: () => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); }, }); } export function useSetSkillPublished() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ skillName, published, squareId, }: { skillName: string; published: boolean; squareId?: string; }) => setSkillPublished(skillName, published, squareId), onSuccess: () => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); // Unpublishing triggers the backend cascade that strips this skill // from every referencing agent's config.yaml, so the cached agent // list (agent.skills) is now stale. void queryClient.invalidateQueries({ queryKey: ["agents"] }); }, }); } export function useSetSkillState() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ skillName, state }: { skillName: string; state: SkillState }) => setSkillState(skillName, state), onSuccess: () => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); }, }); } export function useSetSkillPinned() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ skillName, pinned }: { skillName: string; pinned: boolean }) => setSkillPinned(skillName, pinned), onSuccess: () => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); }, }); } export function useSetSkillFeatured() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ skillName, featured }: { skillName: string; featured: boolean }) => setSkillFeatured(skillName, featured), onSuccess: () => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); }, }); } export function useDuplicateSkill() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ sourceName, newName, }: { sourceName: string; newName: string; }) => duplicateSkill(sourceName, newName), onSuccess: () => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); }, }); } export function useDeleteCustomSkill() { const queryClient = useQueryClient(); return useMutation({ mutationFn: (skillName: string) => deleteCustomSkill(skillName), onSuccess: () => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); // Deletion triggers the backend cascade that strips this skill from // every referencing agent's config.yaml, so the cached agent list // (agent.skills) is now stale. void queryClient.invalidateQueries({ queryKey: ["agents"] }); }, }); } export function useSkillFiles(skillName: string | null) { return useQuery({ queryKey: ["skill-files", skillName], queryFn: () => getSkillFiles(skillName!), enabled: !!skillName, }); } export function useSkillFileContent(skillName: string | null, path: string | null) { return useQuery({ queryKey: ["skill-file", skillName, path], queryFn: () => getSkillFileContent(skillName!, path!), enabled: !!skillName && !!path, }); } export function useSaveSkillFile() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ skillName, path, content, }: { skillName: string; path: string; content: string; }) => saveSkillFile(skillName, path, content), onSuccess: (_data, { skillName, path }) => { void queryClient.invalidateQueries({ queryKey: ["skill-files", skillName] }); void queryClient.invalidateQueries({ queryKey: ["skill-file", skillName, path] }); // SKILL.md edits also affect the source-tab view and skill metadata. if (path === "SKILL.md") { void queryClient.invalidateQueries({ queryKey: ["skill-content", skillName] }); void queryClient.invalidateQueries({ queryKey: ["skill", skillName] }); } }, }); } export function useDeleteSkillFile() { const queryClient = useQueryClient(); return useMutation({ mutationFn: ({ skillName, path, }: { skillName: string; path: string; }) => deleteSkillFile(skillName, path), onSuccess: (_data, { skillName, path }) => { void queryClient.invalidateQueries({ queryKey: ["skill-files", skillName] }); void queryClient.removeQueries({ queryKey: ["skill-file", skillName, path] }); }, }); } export function useDeleteBuiltinSkill() { const queryClient = useQueryClient(); return useMutation({ mutationFn: deleteBuiltinSkill, onSuccess: () => { void queryClient.invalidateQueries({ queryKey: ["skills"] }); void queryClient.invalidateQueries({ queryKey: ["admin-skills"] }); }, }); }