Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
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,
};
}