dsh-skill-hub 0.3.7 → 0.3.8

package/src/client/panel/hooks/shared.ts

@@ -0,0 +1,81 @@
+/**
+ * hooks 共享层：域 hooks 之间传递的通知接口、状态机类型、轮询常量、
+ * 每日自动检查 helpers。从 useSkillHub.ts 原样搬出，行为不变。
+ */
+
+import type { MarketCheckResponse, MarketSourceRecord, RepoDiscoverResponse, UpdateCheckResponse } from '../../../protocol.ts'
+
+/**
+ * 跨域共享的通知原语：聚合根用稳定的 setState setter 实现一次，
+ * 各域 hooks 只调接口，不直接碰别人的 state。对象本身经 useMemo
+ * 常驻，域回调的 useCallback 依赖它不会失稳。
+ */
+export interface FlowNotices {
+  /** 报错条幅（覆盖旧报错）。 */
+  fail: (message: string) => void
+  /** 清掉报错条幅。 */
+  clearFail: () => void
+  /** 成功条幅（null = 清掉）。 */
+  succeed: (message: string | null) => void
+  /** tag 域忙碌开关（多域共用）。 */
+  setTagBusy: (busy: boolean) => void
+  /** 整组操作忙碌开关（toggle-batch 与全部更新共用）。 */
+  setBatchBusy: (busy: boolean) => void
+}
+
+/** Catalog poll interval while the panel is mounted (the provider watcher feeds this). */
+export const POLL_MS = 5000
+/** Relaxed poll for slower-changing data (stats, groups, sources, config). */
+export const SLOW_POLL_MS = 60_000
+/** 空统计补捞上限：冷启动全量扫描（数十 MB 会话日志）可能超过 2 分钟，72 次约 6 分钟内保持 5 秒粒度，之后交回 60 秒慢轮询。 */
+export const USES_CATCH_UP_MAX = 72
+
+/** localStorage key of the last daily auto-check timestamp (survives sessions). */
+export const AUTO_CHECK_KEY = 'skill-hub.last-auto-check'
+/** Daily auto-check interval: at most one network round per day. */
+export const AUTO_CHECK_INTERVAL_MS = 24 * 60 * 60_000
+
+/** Whether the daily auto-check should run now (first visit or ≥24h since the last). */
+export function shouldAutoCheck(): boolean {
+  try {
+    const raw = localStorage.getItem(AUTO_CHECK_KEY)
+    const last = raw === null ? NaN : Number(raw)
+    if (!Number.isFinite(last)) return true
+    return Date.now() - last >= AUTO_CHECK_INTERVAL_MS
+  } catch {
+    // 无 localStorage（隐私模式等）：每次打开都尝试，服务端 5 分钟节流兜底。
+    return true
+  }
+}
+
+/** Record that the daily auto-check ran. */
+export function markAutoChecked(): void {
+  try {
+    localStorage.setItem(AUTO_CHECK_KEY, String(Date.now()))
+  } catch {
+    // 无 localStorage：不记录，下次打开仍会尝试（服务端节流兜底）。
+  }
+}
+
+/** One-shot self-update check state. */
+export type UpdateState =
+  | { status: 'idle' }
+  | { status: 'checking' }
+  | { status: 'ready'; data: UpdateCheckResponse }
+  | { status: 'error'; message: string }
+
+/** Repo scanner/import state (drives the market source preview). */
+export type RepoDiscoverState =
+  | { status: 'idle' }
+  | { status: 'scanning' }
+  | { status: 'ready'; data: RepoDiscoverResponse }
+  | { status: 'error'; message: string }
+
+/** Market sources list state. */
+export type MarketState = { status: 'loading' | 'ready' | 'error'; repos: MarketSourceRecord[] }
+
+/** One market source's update-check outcome. */
+export type MarketCheckResult = MarketCheckResponse['results'][number]
+
+/** skillName → 调用次数/末次使用（统计域产出，目录排序消费）。 */
+export type UsesMap = ReadonlyMap<string, { count: number; lastUsed?: number }>

package/src/client/panel/hooks/useCatalogFlow.ts

@@ -0,0 +1,211 @@
+/**
+ * useCatalogFlow — 目录域：catalog 加载、详情、开关（单个/禁用态/批量）、
+ * 新建、诊断修复，以及列表过滤/排序派生。跨域刷新只通过 shared 通知，
+ * 不直接碰其他域的 state。
+ */
+
+import { useCallback, useMemo, useRef, useState, type FormEvent } from 'react'
+import type {
+  CatalogResponse,
+  CatalogSkill,
+  DisabledSkill,
+  SkillDetail,
+  WritableRoot,
+} from '../../../protocol.ts'
+import type { SkillHubApi } from '../../api.ts'
+import { errorMessage, tt } from '../../helpers.ts'
+import { sortSkills, type SortKey } from '../../grouping.ts'
+import type { FlowNotices, UsesMap } from './shared.ts'
+
+export function useCatalogFlow(
+  api: SkillHubApi,
+  uses: UsesMap,
+  shared: FlowNotices,
+  /** 技能总数 >80 时折叠 personal 分组（聚合根实现，状态归它）。 */
+  collapsePersonal: () => void,
+  /** 清掉来源筛选（状态归聚合根，这里只在清空筛选项时调用）。 */
+  clearSourceFilter: () => void,
+) {
+  const [catalog, setCatalog] = useState<CatalogResponse | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [detail, setDetail] = useState<SkillDetail | null>(null)
+  const [detailLoading, setDetailLoading] = useState(false)
+  const [busyNames, setBusyNames] = useState<ReadonlySet<string>>(new Set())
+  const [search, setSearch] = useState('')
+  /** 工作区（项目）路径；空 = 只看用户级技能。 */
+  const [workspace, setWorkspace] = useState('')
+  const [showForm, setShowForm] = useState(false)
+  const [formName, setFormName] = useState('')
+  const [formDesc, setFormDesc] = useState('')
+  const [formRoot, setFormRoot] = useState<WritableRoot>('user-dsh')
+  const [formBusy, setFormBusy] = useState(false)
+  const [formMessage, setFormMessage] = useState<{ kind: 'error' | 'success'; text: string } | null>(null)
+  const [fixingPaths, setFixingPaths] = useState<ReadonlySet<string>>(new Set())
+  const [invocationFilter, setInvocationFilter] = useState<'all' | 'model' | 'user'>('all')
+  const [sortKey, setSortKey] = useState<SortKey>('name')
+
+  const autoCollapsedPersonal = useRef(false)
+
+  const load = useCallback(async (): Promise<void> => {
+    try {
+      const next = await api.catalog(workspace !== '' ? { cwd: workspace } : undefined)
+      setCatalog(next)
+      if (!autoCollapsedPersonal.current && next.skills.length + next.disabled.length > 80) {
+        autoCollapsedPersonal.current = true
+        collapsePersonal()
+      }
+      shared.clearFail()
+    } catch (error) {
+      shared.fail(errorMessage(error))
+    } finally {
+      setLoading(false)
+    }
+  }, [api, workspace, shared, collapsePersonal])
+
+  const openDetail = useCallback(async (name: string): Promise<void> => {
+    setDetailLoading(true)
+    shared.clearFail()
+    try {
+      setDetail(await api.skill(name, workspace !== '' ? { cwd: workspace } : undefined))
+    } catch (error) {
+      shared.fail(errorMessage(error))
+    } finally {
+      setDetailLoading(false)
+    }
+  }, [api, workspace, shared])
+
+  const toggle = useCallback(async (skill: CatalogSkill, enabled: boolean): Promise<void> => {
+    setBusyNames((previous) => new Set(previous).add(skill.name))
+    shared.clearFail()
+    try {
+      const next = await api.toggle(skill.name, enabled)
+      setCatalog(next)
+    } catch (error) {
+      shared.fail(errorMessage(error))
+    } finally {
+      setBusyNames((previous) => {
+        const next = new Set(previous)
+        next.delete(skill.name)
+        return next
+      })
+    }
+  }, [api, shared])
+
+  const enableDisabled = useCallback(async (record: DisabledSkill): Promise<void> => {
+    setBusyNames((previous) => new Set(previous).add(record.name))
+    shared.clearFail()
+    try {
+      const next = await api.toggle(record.name, true)
+      setCatalog(next)
+    } catch (error) {
+      shared.fail(errorMessage(error))
+    } finally {
+      setBusyNames((previous) => {
+        const next = new Set(previous)
+        next.delete(record.name)
+        return next
+      })
+    }
+  }, [api, shared])
+
+  /** Toggle an explicit name set in one write (enables disabled members too). */
+  const batchToggleNames = useCallback(async (names: string[], enabled: boolean): Promise<void> => {
+    if (names.length === 0) return
+    shared.setBatchBusy(true)
+    shared.clearFail()
+    try {
+      const next = await api.toggleBatch(names, enabled)
+      setCatalog(next.catalog)
+      if (next.failures.length > 0) {
+        shared.fail('toggle-batch: ' + next.failures.map((failure) => failure.name + ': ' + failure.error).join('; '))
+      }
+    } catch (error) {
+      shared.fail(errorMessage(error))
+    } finally {
+      shared.setBatchBusy(false)
+    }
+  }, [api, shared])
+
+  const fixDiagnostic = useCallback(async (path: string): Promise<void> => {
+    setFixingPaths((previous) => new Set(previous).add(path))
+    shared.clearFail()
+    try {
+      const confirmed = window.confirm(tt('diag.fixConfirm', { path }))
+      if (!confirmed) return
+      await api.fixDiagnostic(path)
+      await load()
+      shared.succeed(tt('diag.fixed'))
+    } catch (error) {
+      shared.fail(errorMessage(error))
+    } finally {
+      setFixingPaths((previous) => {
+        const next = new Set(previous)
+        next.delete(path)
+        return next
+      })
+    }
+  }, [api, load, shared])
+
+  const create = useCallback(async (event: FormEvent): Promise<void> => {
+    event.preventDefault()
+    setFormBusy(true)
+    setFormMessage(null)
+    shared.succeed(null)
+    try {
+      const result = await api.create({ name: formName, description: formDesc, root: formRoot })
+      // The form closes on success, so the confirmation lives in the green
+      // banner outside it (a success message inside the closing form is
+      // never visible).
+      shared.succeed(tt('form.success') + result.path)
+      setFormName('')
+      setFormDesc('')
+      setShowForm(false)
+      await load()
+    } catch (error) {
+      setFormMessage({ kind: 'error', text: tt('form.error') + errorMessage(error) })
+    } finally {
+      setFormBusy(false)
+    }
+  }, [api, formName, formDesc, formRoot, load, shared])
+
+  // ------------------------------------------------------------- derived
+
+  const normalized = search.trim().toLocaleLowerCase()
+
+  /** 当前启用且可写的技能名（组开关只作用于它们）。 */
+  const actionNames = useMemo(() => new Set((catalog?.skills ?? []).filter((skill) => skill.writable).map((skill) => skill.name)), [catalog])
+
+  /** 当前启用的全部技能名（含只读，用于派生开关状态）。 */
+  const viewNames = useMemo(() => new Set((catalog?.skills ?? []).map((skill) => skill.name)), [catalog])
+
+  const filtered = useMemo(() => (catalog?.skills ?? []).filter((skill) => {
+    if (invocationFilter === 'model' && !skill.invocation.modelInvocable) return false
+    if (invocationFilter === 'user' && !skill.invocation.userInvocable) return false
+    if (normalized.length === 0) return true
+    return skill.name.toLocaleLowerCase().includes(normalized)
+      || skill.description.toLocaleLowerCase().includes(normalized)
+      || skill.displayName?.toLocaleLowerCase().includes(normalized)
+      || skill.shortDescription?.toLocaleLowerCase().includes(normalized)
+  }), [catalog, normalized, invocationFilter])
+  /** Rows actually rendered with a shortened description (shortDescription in use). */
+  const shortenedCount = useMemo(() => filtered.filter((skill) => skill.shortDescription !== undefined).length, [filtered])
+  /** 排序后的技能列表（所有视图共用；调用次数未知按 0 处理）。 */
+  const sorted = useMemo(() => sortSkills(filtered, sortKey, (name) => uses.get(name)?.count), [filtered, sortKey, uses])
+
+  /** Clear the list filters (search + source + invocation) back to the full view. */
+  const clearListFilters = useCallback((): void => {
+    setSearch('')
+    clearSourceFilter()
+    setInvocationFilter('all')
+  }, [clearSourceFilter])
+
+  return {
+    catalog, loading, detail, detailLoading, busyNames, search, workspace,
+    showForm, formName, formDesc, formRoot, formBusy, formMessage, fixingPaths,
+    invocationFilter, sortKey, normalized, actionNames, viewNames,
+    filtered, sorted, shortenedCount,
+    setDetail, setSearch, setWorkspace, setShowForm, setFormName, setFormDesc,
+    setFormRoot, setFormMessage, setInvocationFilter, setSortKey,
+    load, openDetail, toggle, enableDisabled, batchToggleNames, fixDiagnostic, create, clearListFilters,
+  }
+}

package/src/client/panel/hooks/useGroupFlow.ts

@@ -0,0 +1,240 @@
+/**
+ * useGroupFlow — 分组域：groups 加载、tag 新建/删除/成员/重排、集合重排、
+ * 来源顶层重排、组开关与冲突解决。目录侧只消费 batchToggleNames +
+ * actionNames（聚合根传入），不碰目录 state。
+ */
+
+import { useCallback, useState, type FormEvent } from 'react'
+import type {
+  CollectionReorderRequest,
+  GroupsResponse,
+  SkillTag,
+  SourceGroupReorderRequest,
+  TagDeleteRequest,
+  TagMembersRequest,
+  TagReorderRequest,
+} from '../../../protocol.ts'
+import type { SkillHubApi } from '../../api.ts'
+import { errorMessage } from '../../helpers.ts'
+import { conflictsOnClose, type GroupSwitchState } from '../../grouping.ts'
+import type { FlowNotices } from './shared.ts'
+import type { ConflictDialogState } from '../dialogs.tsx'
+
+export function useGroupFlow(
+  api: SkillHubApi,
+  shared: FlowNotices,
+  /** 整组开关的执行器（目录域提供，stable）。 */
+  batchToggleNames: (names: string[], enabled: boolean) => Promise<void>,
+  /** 当前启用且可写的技能名（目录域派生）。 */
+  actionNames: ReadonlySet<string>,
+) {
+  const [groupsState, setGroupsState] = useState<GroupsResponse | null>(null)
+  const [conflictDialog, setConflictDialog] = useState<ConflictDialogState | null>(null)
+  const [editingTag, setEditingTag] = useState<SkillTag | null>(null)
+  const [editName, setEditName] = useState('')
+  const [membersDraft, setMembersDraft] = useState<ReadonlySet<string>>(new Set())
+  const [newTagName, setNewTagName] = useState('')
+  const [editSearch, setEditSearch] = useState('')
+
+  /** 加载用户 tag 分组 + 系统集合组 + origin 映射。 */
+  const loadGroups = useCallback(async (): Promise<void> => {
+    try {
+      setGroupsState(await api.groups())
+    } catch (error) {
+      shared.fail(errorMessage(error))
+    }
+  }, [api, shared])
+
+  /** 把最新的 tag 列表合并进 groups 状态（tags 以外的字段保持原样）。 */
+  const applyTags = useCallback((tags: SkillTag[]): void => {
+    setGroupsState((previous) => previous === null
+      ? { ok: true, tags, collections: [], origins: {} }
+      : { ...previous, tags })
+  }, [])
+
+  /** 所有分组：key → 成员名（tag 与来源集合）。 */
+  const groupMap = useCallback((): Map<string, string[]> => {
+    const map = new Map<string, string[]>()
+    for (const tag of groupsState?.tags ?? []) map.set('tag:' + tag.id, tag.skillNames)
+    for (const collection of groupsState?.collections ?? []) map.set('col:' + collection.name, collection.skillNames)
+    return map
+  }, [groupsState])
+
+  /**
+   * Toggle a whole group via its tri-state switch. Closing with members that
+   * are enabled in other groups opens the conflict dialog instead.
+   */
+  const toggleGroup = useCallback((key: string, name: string, view: GroupSwitchState): void => {
+    const members = groupMap().get(key) ?? []
+    if (members.length === 0) return
+    if (view === 'off') {
+      void batchToggleNames(members, true)
+      return
+    }
+    const others = [...groupMap().entries()].filter(([otherKey]) => otherKey !== key).map(([, memberNames]) => ({ members: memberNames }))
+    const conflicts = conflictsOnClose(members, actionNames, others)
+    if (conflicts.length > 0) {
+      setConflictDialog({ key, name, conflicts })
+    } else {
+      void batchToggleNames(members.filter((member) => actionNames.has(member)), false)
+    }
+  }, [groupMap, actionNames, batchToggleNames])
+
+  /** Resolve the open conflict dialog. */
+  const resolveConflict = useCallback(async (closeAll: boolean): Promise<void> => {
+    const dialog = conflictDialog
+    if (dialog === null) return
+    setConflictDialog(null)
+    const members = groupMap().get(dialog.key) ?? []
+    if (closeAll) {
+      await batchToggleNames(members.filter((member) => actionNames.has(member)), false)
+    } else {
+      await batchToggleNames(
+        members.filter((member) => actionNames.has(member) && !dialog.conflicts.includes(member)),
+        false,
+      )
+    }
+  }, [conflictDialog, groupMap, actionNames, batchToggleNames])
+
+  /** 新建一个空 tag 分组。 */
+  const createTag = useCallback(async (event: FormEvent): Promise<void> => {
+    event.preventDefault()
+    const name = newTagName.trim()
+    if (name === '') return
+    shared.setTagBusy(true)
+    shared.clearFail()
+    try {
+      applyTags(await api.saveTag({ name }))
+      setNewTagName('')
+    } catch (error) {
+      shared.fail(errorMessage(error))
+    } finally {
+      shared.setTagBusy(false)
+    }
+  }, [api, applyTags, newTagName, shared])
+
+  /** 删除一个 tag 分组（不影响技能文件）。 */
+  const deleteTag = useCallback(async (id: string): Promise<void> => {
+    shared.setTagBusy(true)
+    shared.clearFail()
+    try {
+      applyTags(await api.deleteTag(id))
+      setEditingTag(null)
+    } catch (error) {
+      shared.fail(errorMessage(error))
+    } finally {
+      shared.setTagBusy(false)
+    }
+  }, [api, applyTags, shared])
+
+  /** 重命名 tag，或保存成员勾选后回到列表。 */
+  const saveTag = useCallback(async (id: string, name: string, memberNames: string[] | null): Promise<void> => {
+    shared.setTagBusy(true)
+    shared.clearFail()
+    try {
+      const safeName = name.trim()
+      let tags: SkillTag[] | null = null
+      if (safeName !== '') tags = await api.saveTag({ id, name: safeName })
+      if (memberNames !== null) tags = await api.setTagMembers(id, memberNames)
+      if (tags === null) return
+      applyTags(tags)
+      setEditingTag(null)
+    } catch (error) {
+      shared.fail(errorMessage(error))
+    } finally {
+      shared.setTagBusy(false)
+    }
+  }, [api, applyTags, shared])
+
+  /** 拖拽重排场景分组 */
+  const reorderTags = useCallback(async (orderedIds: string[]): Promise<void> => {
+    shared.setTagBusy(true)
+    shared.clearFail()
+    try {
+      const tags = await api.reorderTags(orderedIds)
+      applyTags(tags)
+    } catch (error) {
+      const msg = errorMessage(error)
+      if (msg.includes('404') || msg.toLowerCase().includes('not found')) {
+        // 旧宿主无此路由：本地重排
+        const byId = new Map(groupsState?.tags.map((t) => [t.id, t] as const) ?? [])
+        const reordered = orderedIds.map((id) => byId.get(id)).filter((t): t is NonNullable<typeof t> => t !== undefined)
+        if (reordered.length === orderedIds.length) {
+          applyTags(reordered as typeof groupsState extends { tags: infer T } ? T : never)
+          shared.succeed('已临时调整顺序（本地生效，重启宿主后持久化）')
+        } else {
+          shared.fail(msg)
+        }
+      } else {
+        shared.fail(msg)
+      }
+    } finally {
+      shared.setTagBusy(false)
+    }
+  }, [api, applyTags, groupsState, shared])
+
+  /** 拖拽重排来源集合 */
+  const reorderCollections = useCallback(async (orderedNames: string[]): Promise<void> => {
+    shared.setTagBusy(true)
+    shared.clearFail()
+    try {
+      const collections = await api.reorderCollections(orderedNames)
+      setGroupsState((prev) => prev === null ? prev : { ...prev, collections })
+      void loadGroups()
+    } catch (error) {
+      const msg = errorMessage(error)
+      // 404 说明宿主仍在跑旧版（需重启后才有新路由），降级为本地即时生效
+      if (msg.includes('404') || msg.toLowerCase().includes('not found')) {
+        setGroupsState((prev) => {
+          if (prev === null) return prev
+          const map = new Map(prev.collections.map((c) => [c.name, c] as const))
+          const reordered = orderedNames.map((n) => map.get(n)).filter((c): c is NonNullable<typeof c> => c !== undefined)
+          // 补上未在 orderedNames 中的集合（新出现的）
+          for (const c of prev.collections) if (!reordered.some((r) => r.name === c.name)) reordered.push(c)
+          return { ...prev, collections: reordered }
+        })
+        shared.succeed('已临时调整顺序（本地生效，重启宿主后持久化）')
+      } else {
+        shared.fail(msg)
+      }
+    } finally {
+      shared.setTagBusy(false)
+    }
+  }, [api, loadGroups, shared])
+
+  /** 拖拽重排来源顶层分组（project / col:xxx / personal 全量可拖） */
+  const reorderSourceGroups = useCallback(async (orderedKeys: string[]): Promise<void> => {
+    shared.setTagBusy(true)
+    shared.clearFail()
+    try {
+      await api.reorderSourceGroups(orderedKeys)
+      await loadGroups()
+    } catch (error) {
+      const msg = errorMessage(error)
+      if (msg.includes('404') || msg.toLowerCase().includes('not found')) {
+        // 旧宿主无此路由：本地重排顶层顺序，提示重启后持久化
+        setGroupsState((prev) => {
+          if (prev === null) return prev
+          // 本地重排 collections 以匹配 topOrderedKeys 中的 col:xxx 顺序
+          const colOrder = orderedKeys.filter((k) => k.startsWith('col:')).map((k) => k.slice(4))
+          const map = new Map(prev.collections.map((c) => [c.name, c] as const))
+          const reordered = colOrder.map((n) => map.get(n)).filter((c): c is NonNullable<typeof c> => c !== undefined)
+          for (const c of prev.collections) if (!reordered.some((r) => r.name === c.name)) reordered.push(c)
+          return { ...prev, collections: reordered, sourceGroupOrder: orderedKeys }
+        })
+        shared.succeed('已临时调整顺序（本地生效，重启宿主后持久化）')
+      } else {
+        shared.fail(msg)
+      }
+    } finally {
+      shared.setTagBusy(false)
+    }
+  }, [api, loadGroups, shared])
+
+  return {
+    groupsState, conflictDialog, editingTag, editName, membersDraft, newTagName, editSearch,
+    setConflictDialog, setEditingTag, setEditName, setMembersDraft, setNewTagName, setEditSearch,
+    loadGroups, applyTags, groupMap, toggleGroup, resolveConflict,
+    createTag, deleteTag, saveTag, reorderTags, reorderCollections, reorderSourceGroups,
+  }
+}