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。

7.6 KB
Raw Blame
import { useRetainedHomeState, type HomeViewSession } from './homeViewSession';
import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
import { useTranslation } from 'react-i18next';
import { useDeviceLink } from '@/device-link/DeviceLinkContext';
import { unresponsiveDevicesStore } from '@/device-link/unresponsiveDevicesStore';
import {
  CONVERSATION_SEARCH_LIMIT,
  conversationSearchActiveFilterCount,
  conversationSearchWorkingDirs,
  reconcileConversationSearchProjectSelection,
  scopedConversationSearchOrigins,
  searchConversationsAcrossDevices,
  cachedSessionForSearchResult,
  conversationSearchSessionCacheKey,
  toSearchListItem,
  type ConversationSearchDeviceOrigin,
  type ConversationSearchListItem,
  type ConversationSearchProjectOption,
  type ConversationSearchProjectSelection,
} from '@/session/conversationSearch';
import { remoteSessionStore } from '@/session/remoteSessionStore';
import { useStableValue } from '@/utils/useStableValue';
import type { ProjectAliasDisplayIndex } from '@cindy/maker-shared/project-alias-sync';
import type {
  ConversationSearchAgentFilter,
  ConversationSearchLastActivityFilter,
  ConversationSearchSortBy,
  ConversationSearchStatusFilter,
} from '@cindy/maker-shared/conversation-search';

export const CONVERSATION_SEARCH_DEBOUNCE_MS = 250;

export type ConversationSearchStatus = 'idle' | 'searching' | 'ready';

export function useConversationSearch({
  origins,
  enabled,
  retainedState,
  lockedWorkingDirs,
  projects,
  projectAliases,
}: {
  origins: readonly ConversationSearchDeviceOrigin[];
  enabled: boolean;
  retainedState?: HomeViewSession;
  lockedWorkingDirs?: string[] | null;
  projects?: readonly ConversationSearchProjectOption[];
  projectAliases?: ProjectAliasDisplayIndex;
}): {
  query: string;
  setQuery: (value: string) => void;
  status: ConversationSearchStatus;
  results: ConversationSearchListItem[];
  sortBy: ConversationSearchSortBy;
  setSortBy: (value: ConversationSearchSortBy) => void;
  statusFilter: ConversationSearchStatusFilter;
  setStatusFilter: (value: ConversationSearchStatusFilter) => void;
  agentFilter: ConversationSearchAgentFilter;
  setAgentFilter: (value: ConversationSearchAgentFilter) => void;
  lastActivityFilter: ConversationSearchLastActivityFilter;
  setLastActivityFilter: (value: ConversationSearchLastActivityFilter) => void;
  projectSelection: ConversationSearchProjectSelection;
  setProjectSelection: (value: ConversationSearchProjectSelection) => void;
  lockedWorkingDirs: string[] | null;
  activeFilterCount: number;
  resetFilters: () => void;
} {
  const { invoke } = useDeviceLink();
  const { t } = useTranslation();
  const [query, setQuery] = useRetainedHomeState(retainedState, 'search.query', '');
  const [status, setStatus] = useState<ConversationSearchStatus>('idle');
  const [results, setResults] = useState<ConversationSearchListItem[]>([]);
  const [sortBy, setSortBy] = useRetainedHomeState<ConversationSearchSortBy>(retainedState, 'search.sortBy', 'relevance');
  const [statusFilter, setStatusFilter] = useRetainedHomeState<ConversationSearchStatusFilter>(retainedState, 'search.statusFilter', 'all');
  const [agentFilter, setAgentFilter] = useRetainedHomeState<ConversationSearchAgentFilter>(retainedState, 'search.agentFilter', 'all');
  const [lastActivityFilter, setLastActivityFilter] =
    useRetainedHomeState<ConversationSearchLastActivityFilter>(retainedState, 'search.lastActivityFilter', 'all');
  const [projectSelection, setProjectSelection] = useRetainedHomeState<ConversationSearchProjectSelection>(retainedState, 'search.projectSelection', 'all');
  const requestSeq = useRef(0);
  const unnamedLabel = t('session.menu.unnamedTitle');
  const visibleProjectKeys = useMemo(
    () => (projects ?? []).map((project) => project.key),
    [projects],
  );
  const visibleKey = visibleProjectKeys.join('|');
  const lockedDirs = useMemo(
    () => (lockedWorkingDirs?.length ? [...lockedWorkingDirs] : null),
    [lockedWorkingDirs?.join('|') ?? ''],
  );
  const scopedOrigins = useStableValue(
    useMemo(
      () =>
        (lockedDirs
          ? [...origins]
          : scopedConversationSearchOrigins(origins, projectSelection, projects ?? [])
        )
          .map((origin) => ({
            ...origin,
            workingDirs: origin.workingDirs ? [...origin.workingDirs].sort() : null,
          }))
          .sort((a, b) => a.deviceId.localeCompare(b.deviceId)),
      [lockedDirs, origins, projectSelection, projects],
    ),
    (a, b) => JSON.stringify(a) === JSON.stringify(b),
  );

  useEffect(() => {
    if (!projects) return;
    setProjectSelection((current) => reconcileConversationSearchProjectSelection(current, visibleProjectKeys));
  }, [projects, visibleKey, visibleProjectKeys]);

  const workingDirs = useMemo(
    () => conversationSearchWorkingDirs({ lockedWorkingDirs: lockedDirs }),
    [lockedDirs],
  );
  const activeFilterCount = conversationSearchActiveFilterCount({
    agentKind: agentFilter,
    lastActivity: lastActivityFilter,
    lockedWorkingDirs: lockedDirs,
    projectSelection,
    status: statusFilter,
  });
  const resetFilters = useCallback(() => {
    setStatusFilter('all');
    setAgentFilter('all');
    setLastActivityFilter('all');
    setProjectSelection('all');
  }, []);

  // Publish "searching" before paint, including the debounce interval. Otherwise
  // an empty local projection can briefly claim there are no matching tasks.
  useLayoutEffect(() => {
    const trimmed = query.trim();
    if (!enabled || !trimmed) {
      requestSeq.current += 1;
      setStatus('idle');
      setResults([]);
      return;
    }

    setStatus('searching');
    const seq = ++requestSeq.current;
    const timer = setTimeout(() => {
      void searchConversationsAcrossDevices(
        scopedOrigins,
        {
          query: trimmed,
          limit: CONVERSATION_SEARCH_LIMIT,
          semanticMode: 'keyword',
          sortBy,
          unnamedLabel,
          filters: {
            agentKind: agentFilter,
            lastActivity: lastActivityFilter,
            status: statusFilter,
            workingDirs,
          },
        },
        {
          invoke,
          getCachedSessions: () => remoteSessionStore.getSessions(),
          projectAliases,
          isDeviceUnresponsive: (deviceId) => unresponsiveDevicesStore.has(deviceId),
        },
      ).then((page) => {
        if (seq !== requestSeq.current) return;
        const now = Date.now();
        const cachedByKey = new Map(
          remoteSessionStore.getSessions().map((session) => [
            conversationSearchSessionCacheKey(session),
            session,
          ]),
        );
        setResults(page.results.map((item) => (
          toSearchListItem(item, now, unnamedLabel, cachedSessionForSearchResult(item, cachedByKey))
        )));
        setStatus('ready');
      }).catch(() => {
        if (seq !== requestSeq.current) return;
        setResults([]);
        setStatus('ready');
      });
    }, CONVERSATION_SEARCH_DEBOUNCE_MS);

    return () => {
      requestSeq.current += 1;
      clearTimeout(timer);
    };
  }, [
    agentFilter,
    enabled,
    invoke,
    lastActivityFilter,
    scopedOrigins,
    query,
    sortBy,
    statusFilter,
    unnamedLabel,
    workingDirs,
    projectAliases,
  ]);

  return {
    query,
    setQuery,
    status,
    results,
    sortBy,
    setSortBy,
    statusFilter,
    setStatusFilter,
    agentFilter,
    setAgentFilter,
    lastActivityFilter,
    setLastActivityFilter,
    projectSelection,
    setProjectSelection,
    lockedWorkingDirs: lockedDirs,
    activeFilterCount,
    resetFilters,
  };
}