Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

11.2 KB
Raw Blame
/**
 * useCollapsedProjects — Sidebar Project 折叠状态管理
 * ---------------------------------------------------------------------------
 * - owner-scoped localStorage key derived from `cc-agent.sidebar.collapsedProjects`
 * - 默认展开(无条目 = 展开);仅持久化已折叠项
 * - mount 时执行一次 30 天 GC(清理 lastSeenAt 过期且不在当前 active 集合的项)
 *
 * API:
 *   collapsed         Set<string> — 当前所有折叠的 workingDir
 *   toggle(dir)       折叠/展开单项
 *   collapseAll()     把 activeWorkingDirs 全部塞入折叠集
 *   expandAll()       把 activeWorkingDirs 从折叠集移除
 *   isAllCollapsed    activeWorkingDirs 是否全部都折叠
 */

import { useCallback, useLayoutEffect, useMemo, useRef, useState } from 'react';
import { createLogger } from '@/lib/logger';
import { readSidebarOwnerStorage, writeSidebarOwnerStorage } from '@/lib/sidebarOwnerStorage';
import { normalizeProjectKey, projectKeyComparisonKey } from '../lib/projectGrouping';

const log = createLogger('UseCollapsedProjects');

const STORAGE_KEY = 'cc-agent.sidebar.collapsedProjects';
const GC_DAYS = 30;
const GC_MS = GC_DAYS * 24 * 60 * 60 * 1000;

interface StoredEntry {
  /** 标记折叠态——只存折叠项,展开项从 stored 中删除 */
  collapsed: true;
  /** ISO 8601 — 上次写入时间,用于 GC 判定 */
  lastSeenAt: string;
}

type Stored = Record<string, StoredEntry>;

function storedProjectKeyForIdentity(
  stored: Stored,
  projectKeyOrWorkingDir: string,
  localPlatform: string,
): string | null {
  const projectKey = normalizeProjectKey(projectKeyOrWorkingDir);
  if (!projectKey) return null;
  const identity = projectKeyComparisonKey(projectKey, localPlatform) ?? projectKey;
  return (
    Object.keys(stored).find(
      (storedKey) => (projectKeyComparisonKey(storedKey, localPlatform) ?? storedKey) === identity,
    ) ?? null
  );
}

interface UseCollapsedProjectsReturn {
  collapsed: Set<string>;
  toggle: (projectKeyOrWorkingDir: string) => void;
  /** 幂等展开单项:已展开则 no-op。用于"新 session 进折叠 Project 时自动展开"等场景。 */
  expand: (projectKeyOrWorkingDir: string) => void;
  setCollapsed: (projectKeyOrWorkingDir: string, collapsed: boolean) => void;
  collapseAll: () => void;
  expandAll: () => void;
  isAllCollapsed: boolean;
}

function loadFromStorage(ownerId: string | null, localPlatform: string): Stored {
  try {
    const raw = readSidebarOwnerStorage(STORAGE_KEY, ownerId);
    if (!raw) return {};
    const parsed = JSON.parse(raw) as unknown;
    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
      // 浅校验:保留具有 collapsed=true 的条目
      const out: Stored = {};
      for (const [k, v] of Object.entries(parsed as Record<string, unknown>)) {
        if (v && typeof v === 'object') {
          const entry = v as Partial<StoredEntry>;
          if (entry.collapsed === true && typeof entry.lastSeenAt === 'string') {
            const projectKey = normalizeProjectKey(k);
            if (projectKey) {
              const storedKey = storedProjectKeyForIdentity(out, projectKey, localPlatform);
              if (storedKey == null) {
                out[projectKey] = { collapsed: true, lastSeenAt: entry.lastSeenAt };
              } else if (
                new Date(entry.lastSeenAt).getTime() >
                new Date(out[storedKey]!.lastSeenAt).getTime()
              ) {
                out[storedKey] = { collapsed: true, lastSeenAt: entry.lastSeenAt };
              }
            }
          }
        }
      }
      return out;
    }
    return {};
  } catch (err) {
    // JSON parse / localStorage 异常 → 静默回退
    log.warn('failed to load stored state:', err);
    return {};
  }
}

function writeToStorage(next: Stored, ownerId: string | null): void {
  if (!writeSidebarOwnerStorage(STORAGE_KEY, ownerId, JSON.stringify(next))) {
    log.warn('failed to write stored state');
  }
}

export function useCollapsedProjects(
  activeWorkingDirs: readonly string[],
  ownerId: string | null,
  localPlatform: string = '',
): UseCollapsedProjectsReturn {
  const [stored, setStored] = useState<Stored>(() => loadFromStorage(ownerId, localPlatform));
  const loadedOwnerRef = useRef(ownerId);
  const currentOwnerRef = useRef(ownerId);
  currentOwnerRef.current = ownerId;

  // 用 ref 镜像最新的 activeWorkingDirs,让 toggle/collapseAll/expandAll 都能
  // 走"依赖空数组 + 闭包内读 ref.current"的统一模式,避免在 activeWorkingDirs
  // 引用变化时反复重建回调(统一策略,见 reviewer Minor #2)。
  const activeDirsRef = useRef<readonly string[]>(activeWorkingDirs);
  activeDirsRef.current = activeWorkingDirs;

  const updateForOwner = useCallback(
    (updater: (prev: Stored, writeOwnerId: string | null) => Stored) => {
      const expectedOwnerId = ownerId;
      if (currentOwnerRef.current !== expectedOwnerId) return;
      setStored((prev) =>
        currentOwnerRef.current === expectedOwnerId ? updater(prev, expectedOwnerId) : prev,
      );
    },
    [ownerId],
  );

  // mount / owner switch 时先装载当前 owner,再 GC lastSeenAt 过期且不在
  // active 集合的条目。layout effect 避免把上一个 owner 的折叠态绘制一帧。
  useLayoutEffect(() => {
    const cutoff = Date.now() - GC_MS;
    const activeSet = new Set(
      activeDirsRef.current.map(
        (projectKey) => projectKeyComparisonKey(projectKey, localPlatform) ?? projectKey,
      ),
    );
    const ownerChanged = loadedOwnerRef.current !== ownerId;
    const ownerStored = ownerChanged ? loadFromStorage(ownerId, localPlatform) : null;
    loadedOwnerRef.current = ownerId;
    setStored((prev) => {
      const source = ownerStored ?? prev;
      const next: Stored = {};
      let changed = false;
      for (const [dir, entry] of Object.entries(source)) {
        const lastSeen = new Date(entry.lastSeenAt).getTime();
        const fresh = Number.isFinite(lastSeen) && lastSeen >= cutoff;
        const identity = projectKeyComparisonKey(dir, localPlatform) ?? dir;
        if (fresh || activeSet.has(identity)) {
          next[dir] = entry;
        } else {
          changed = true;
        }
      }
      if (changed) {
        writeToStorage(next, ownerId);
        return next;
      }
      return source;
    });
  }, [localPlatform, ownerId]);

  const collapsed = useMemo(() => {
    const activeProjectKeyByIdentity = new Map<string, string>();
    for (const activeWorkingDir of activeWorkingDirs) {
      const projectKey = normalizeProjectKey(activeWorkingDir);
      if (!projectKey) continue;
      const identity = projectKeyComparisonKey(projectKey, localPlatform) ?? projectKey;
      if (!activeProjectKeyByIdentity.has(identity)) {
        activeProjectKeyByIdentity.set(identity, projectKey);
      }
    }

    return new Set(
      Object.keys(stored).map((storedProjectKey) => {
        const identity =
          projectKeyComparisonKey(storedProjectKey, localPlatform) ?? storedProjectKey;
        return activeProjectKeyByIdentity.get(identity) ?? storedProjectKey;
      }),
    );
  }, [activeWorkingDirs, localPlatform, stored]);

  // Callback identity changes only at an owner boundary.
  const toggle = useCallback(
    (projectKeyOrWorkingDir: string) => {
      const projectKey = normalizeProjectKey(projectKeyOrWorkingDir);
      if (!projectKey) return;
      updateForOwner((prev, writeOwnerId) => {
        const next: Stored = { ...prev };
        const storedKey = storedProjectKeyForIdentity(next, projectKey, localPlatform);
        if (storedKey != null) {
          delete next[storedKey];
        } else {
          next[projectKey] = { collapsed: true, lastSeenAt: new Date().toISOString() };
        }
        writeToStorage(next, writeOwnerId);
        return next;
      });
    },
    [localPlatform, updateForOwner],
  );

  // 幂等展开:仅当目标目录当前在折叠集中时才写入,避免无意义的 setState/写盘。
  const expand = useCallback(
    (projectKeyOrWorkingDir: string) => {
      const projectKey = normalizeProjectKey(projectKeyOrWorkingDir);
      if (!projectKey) return;
      updateForOwner((prev, writeOwnerId) => {
        const storedKey = storedProjectKeyForIdentity(prev, projectKey, localPlatform);
        if (storedKey == null) return prev;
        const next: Stored = { ...prev };
        delete next[storedKey];
        writeToStorage(next, writeOwnerId);
        return next;
      });
    },
    [localPlatform, updateForOwner],
  );

  const setCollapsed = useCallback(
    (projectKeyOrWorkingDir: string, nextCollapsed: boolean) => {
      const projectKey = normalizeProjectKey(projectKeyOrWorkingDir);
      if (!projectKey) return;
      updateForOwner((prev, writeOwnerId) => {
        const storedKey = storedProjectKeyForIdentity(prev, projectKey, localPlatform);
        const isCollapsed = storedKey != null;
        if (isCollapsed === nextCollapsed) return prev;
        const next: Stored = { ...prev };
        if (nextCollapsed) {
          next[projectKey] = { collapsed: true, lastSeenAt: new Date().toISOString() };
        } else if (storedKey != null) {
          delete next[storedKey];
        }
        writeToStorage(next, writeOwnerId);
        return next;
      });
    },
    [localPlatform, updateForOwner],
  );

  // collapseAll/expandAll read the latest activeWorkingDirs through the ref;
  // callback identity changes only at an owner boundary.
  const collapseAll = useCallback(() => {
    updateForOwner((prev, writeOwnerId) => {
      const now = new Date().toISOString();
      const next: Stored = { ...prev };
      for (const dir of activeDirsRef.current) {
        const projectKey = normalizeProjectKey(dir);
        if (!projectKey) continue;
        const storedKey = storedProjectKeyForIdentity(next, projectKey, localPlatform);
        next[storedKey ?? projectKey] = { collapsed: true, lastSeenAt: now };
      }
      writeToStorage(next, writeOwnerId);
      return next;
    });
  }, [localPlatform, updateForOwner]);

  const expandAll = useCallback(() => {
    updateForOwner((prev, writeOwnerId) => {
      const next: Stored = { ...prev };
      for (const dir of activeDirsRef.current) {
        const projectKey = normalizeProjectKey(dir);
        if (!projectKey) continue;
        const storedKey = storedProjectKeyForIdentity(next, projectKey, localPlatform);
        if (storedKey != null) delete next[storedKey];
      }
      writeToStorage(next, writeOwnerId);
      return next;
    });
  }, [localPlatform, updateForOwner]);

  const collapsedComparisonKeys = useMemo(
    () =>
      new Set(
        Array.from(collapsed).map(
          (projectKey) => projectKeyComparisonKey(projectKey, localPlatform) ?? projectKey,
        ),
      ),
    [collapsed, localPlatform],
  );

  const isAllCollapsed = useMemo(
    () =>
      activeWorkingDirs.length > 0 &&
      activeWorkingDirs.every((d) => {
        const projectKey = normalizeProjectKey(d);
        if (!projectKey) return false;
        return collapsedComparisonKeys.has(
          projectKeyComparisonKey(projectKey, localPlatform) ?? projectKey,
        );
      }),
    [activeWorkingDirs, collapsedComparisonKeys, localPlatform],
  );

  return { collapsed, toggle, expand, setCollapsed, collapseAll, expandAll, isAllCollapsed };
}