Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* conversationSearchFanout —— 侧栏任务搜索的本机 / device-link fan-out。
*
* 被控端任务不进控制端 SQLite。本机 IPC 与 `local-db:conversations:search` 隧道
* 共用同一份 request,控制端按机器切换栏 / 项目锁定拆 origin 后再合并。
* 纯函数 + 注入依赖,方便单测,不直接碰 store / Electron。
*/
import { conversationSearchTitle } from '../../shared/conversationSearch';
import type {
ConversationSearchLastActivityFilter,
ConversationSearchRequest,
ConversationSearchResponse,
ConversationSearchResultItem,
ConversationSearchSessionStatus,
ConversationSearchSessionSummary,
ConversationSearchSortBy,
ConversationSearchStatusFilter,
} from '../../shared/conversationSearch';
import type { Session } from '@/lib/ccAgent.types';
import { fuzzyMatch } from '@/features/cc-agent/lib/fuzzyMatch';
import { isOrcaWorkerSession } from '@/lib/orcaSessionIdentity';
import {
MACHINE_ALL,
MACHINE_LOCAL,
type MachineSelection,
} from '@/features/device-link/selectedMachineStore';
import {
normalizeProjectKey,
projectKeyComparisonKey,
} from '../../shared/projectKeys';
import { normalizeWorkingDirForComparison, normalizeWorkingDirForGrouping } from '../../shared/workingDir';
import { CINDY_MAKE_ENABLED, isCindyMakeSource } from '@cindy/maker-shared/cindy-make-feature';
export interface ConversationSearchDevice {
deviceId: string;
deviceName: string;
connected: boolean;
}
export function searchDevicesFromSwitcher(
devices: readonly { deviceId: string; name: string; status: string }[],
): ConversationSearchDevice[] {
return devices
.filter((device) => device.status !== 'rejected')
.map((device) => ({
deviceId: device.deviceId,
deviceName: device.name,
connected: device.status === 'connected' || device.status === 'connecting',
}));
}
export interface ConversationSearchProjectTarget {
/** device-link 设备。本机 / SSH 项目不走这条路径,避免丢掉 remoteHostId。 */
deviceId: string;
workingDir: string;
}
export type ConversationSearchOrigin =
| {
kind: 'local';
sessionIds: string[] | null;
workingDirs?: string[] | null;
}
| {
kind: 'remote';
deviceId: string;
deviceName: string | null;
connected: boolean;
sessionIds: string[] | null;
workingDirs?: string[] | null;
};
const LAST_ACTIVITY_DAY_COUNTS: Record<
Exclude<ConversationSearchLastActivityFilter, 'all'>,
number
> = {
'1d': 1,
'3d': 3,
'7d': 7,
'30d': 30,
};
const DAY_MS = 24 * 60 * 60 * 1000;
const LEGACY_REMOTE_LIST_LIMIT = 100;
export function emptyConversationSearchResponse(query = ''): ConversationSearchResponse {
return {
query,
results: [],
vectorUsed: false,
vectorSkipReason: null,
poolCapped: false,
};
}
export function resolveConversationSearchOrigins(args: {
machineSelection: MachineSelection;
sessionIds?: string[] | null;
projectTargets?: readonly ConversationSearchProjectTarget[] | null;
devices: readonly ConversationSearchDevice[];
getSessionDeviceId: (sessionId: string) => string | undefined;
}): ConversationSearchOrigin[] {
const targetOrigins =
args.projectTargets && args.projectTargets.length > 0
? originsFromProjectTargets(args.projectTargets, args.devices)
: [];
const sessionIds = normalizeSessionIds(args.sessionIds);
if (sessionIds && sessionIds.length === 0 && targetOrigins.length === 0) return [];
if (sessionIds && sessionIds.length > 0) {
return mergeProjectAndSessionOrigins(
targetOrigins,
originsFromSessionIds(sessionIds, args.devices, args.getSessionDeviceId),
);
}
if (targetOrigins.length > 0) return targetOrigins;
return originsFromMachineSelection(args.machineSelection, args.devices);
}
function originsFromProjectTargets(
targets: readonly ConversationSearchProjectTarget[],
devices: readonly ConversationSearchDevice[],
): ConversationSearchOrigin[] {
const deviceById = new Map(devices.map((device) => [device.deviceId, device]));
const remoteDirs = new Map<string, string[]>();
for (const target of targets) {
const deviceId = target.deviceId.trim();
const workingDir = normalizeWorkingDirForGrouping(target.workingDir);
if (!deviceId || workingDir == null) continue;
const bucket = remoteDirs.get(deviceId);
if (bucket) {
if (!bucket.includes(workingDir)) bucket.push(workingDir);
} else {
remoteDirs.set(deviceId, [workingDir]);
}
}
return [...remoteDirs].map(([deviceId, workingDirs]) => {
const device = deviceById.get(deviceId);
return {
kind: 'remote' as const,
deviceId,
deviceName: device?.deviceName ?? null,
connected: device?.connected === true,
sessionIds: null,
workingDirs,
};
});
}
function mergeProjectAndSessionOrigins(
targetOrigins: ConversationSearchOrigin[],
sessionOrigins: ConversationSearchOrigin[],
): ConversationSearchOrigin[] {
const targetDeviceIds = new Set(
targetOrigins.flatMap((origin) => (origin.kind === 'remote' ? [origin.deviceId] : [])),
);
return [
...targetOrigins,
...sessionOrigins.filter(
(origin) => origin.kind === 'local' || !targetDeviceIds.has(origin.deviceId),
),
];
}
function originsFromSessionIds(
sessionIds: string[],
devices: readonly ConversationSearchDevice[],
getSessionDeviceId: (sessionId: string) => string | undefined,
): ConversationSearchOrigin[] {
const deviceById = new Map(devices.map((device) => [device.deviceId, device]));
const localIds: string[] = [];
const remoteIds = new Map<string, string[]>();
for (const sessionId of sessionIds) {
const deviceId = getSessionDeviceId(sessionId);
if (!deviceId) {
localIds.push(sessionId);
continue;
}
const bucket = remoteIds.get(deviceId);
if (bucket) bucket.push(sessionId);
else remoteIds.set(deviceId, [sessionId]);
}
const origins: ConversationSearchOrigin[] = [];
if (localIds.length > 0) {
origins.push({ kind: 'local', sessionIds: localIds });
}
for (const [deviceId, ids] of remoteIds) {
const device = deviceById.get(deviceId);
origins.push({
kind: 'remote',
deviceId,
deviceName: device?.deviceName ?? null,
connected: device?.connected === true,
sessionIds: ids,
});
}
return origins;
}
function originsFromMachineSelection(
selection: MachineSelection,
devices: readonly ConversationSearchDevice[],
): ConversationSearchOrigin[] {
const includeLocal = selection === MACHINE_ALL || selection.includes(MACHINE_LOCAL);
const selectedRemoteIds =
selection === MACHINE_ALL ? null : new Set(selection.filter((id) => id !== MACHINE_LOCAL));
const origins: ConversationSearchOrigin[] = [];
if (includeLocal) {
origins.push({ kind: 'local', sessionIds: null });
}
for (const device of devices) {
if (selectedRemoteIds && !selectedRemoteIds.has(device.deviceId)) continue;
origins.push({
kind: 'remote',
deviceId: device.deviceId,
deviceName: device.deviceName,
connected: device.connected,
sessionIds: null,
});
}
return origins;
}
export function stampRemoteSearchResponse(
response: ConversationSearchResponse,
device: { deviceId: string; deviceName?: string | null },
): ConversationSearchResponse {
const results = Array.isArray(response?.results) ? response.results : [];
return {
query: response?.query ?? '',
vectorUsed: response?.vectorUsed === true,
vectorSkipReason: response?.vectorSkipReason ?? null,
poolCapped: response?.poolCapped === true,
results: results.map((item) => ({
...item,
session: {
...item.session,
deviceLinkDeviceId: device.deviceId,
deviceLinkDeviceName: device.deviceName ?? item.session.deviceLinkDeviceName ?? null,
},
})),
};
}
export function conversationSearchResultKey(item: ConversationSearchResultItem): string {
return `${item.session.deviceLinkDeviceId ?? 'local'}:${item.session.id}`;
}
/** Remote hits from origin pages, before the merged display page is truncated. */
export function remoteResultsFromFanoutPages(
pages: readonly ConversationSearchResponse[],
): ConversationSearchResultItem[] {
const byKey = new Map<string, ConversationSearchResultItem>();
for (const page of pages) {
for (const item of page.results) {
if (!CINDY_MAKE_ENABLED && isCindyMakeSource(item.session.source)) continue;
if (!item.session.deviceLinkDeviceId) continue;
const key = conversationSearchResultKey(item);
const existing = byKey.get(key);
if (!existing || item.rankScore > existing.rankScore) {
byKey.set(key, item);
}
}
}
return [...byKey.values()];
}
export function mergeConversationSearchFanout(
pages: readonly ConversationSearchResponse[],
limit: number,
sortBy: ConversationSearchSortBy = 'relevance',
): ConversationSearchResponse {
const byKey = new Map<string, ConversationSearchResultItem>();
for (const page of pages) {
for (const item of page.results) {
if (!CINDY_MAKE_ENABLED && isCindyMakeSource(item.session.source)) continue;
const key = conversationSearchResultKey(item);
const existing = byKey.get(key);
if (!existing || item.rankScore > existing.rankScore) {
byKey.set(key, item);
}
}
}
const results = [...byKey.values()]
.sort((a, b) => compareSearchResults(a, b, sortBy))
.slice(0, Math.max(1, limit));
return {
query: pages[0]?.query ?? '',
results,
vectorUsed: pages.some((page) => page.vectorUsed),
vectorSkipReason: pages.find((page) => page.vectorSkipReason)?.vectorSkipReason ?? null,
poolCapped: pages.some((page) => page.poolCapped),
};
}
export function searchCachedSessionsByTitle(
sessions: readonly Session[],
request: ConversationSearchRequest,
): ConversationSearchResponse {
const query = request.query.trim();
if (!query) return emptyConversationSearchResponse('');
const filters = request.filters ?? {};
const sessionIds = normalizeSessionIds(filters.sessionIds);
if (sessionIds && sessionIds.length === 0) {
return emptyConversationSearchResponse(query);
}
const allowed = sessionIds ? new Set(sessionIds) : null;
const workingDirs = normalizeWorkingDirSet(filters.workingDirs);
const activityCutoff = cutoffForLastActivity(filters.lastActivity ?? 'all');
const titleMatches: Array<{
session: ConversationSearchSessionSummary;
score: number;
indices: number[];
index: number;
}> = [];
sessions.forEach((session, index) => {
// The mirror includes companion chat metadata; ordinary search must not expose it.
if (session.source === 'bot' || (!CINDY_MAKE_ENABLED && isCindyMakeSource(session.source)) || isOrcaWorkerSession(session)) return;
if (allowed && !allowed.has(session.id)) return;
if (!matchesWorkingDirSet(session.workingDir, workingDirs)) return;
if (!matchesStatus(session.status, filters.status ?? 'all')) return;
if (
filters.agentKind &&
filters.agentKind !== 'all' &&
session.agentKind !== filters.agentKind
) {
return;
}
if (activityCutoff !== null && sessionActivityMs(session) < activityCutoff) return;
const title = conversationSearchTitle(session.title, request.unnamedLabel);
const match = fuzzyMatch(title, query);
if (!match) return;
titleMatches.push({
session: sessionToSearchSummary(session),
score: match.score,
indices: match.indices,
index,
});
});
titleMatches.sort(
(a, b) =>
b.score - a.score ||
sessionActivityMs(b.session) - sessionActivityMs(a.session) ||
a.index - b.index,
);
const limit = clampLimit(request.limit);
const results: ConversationSearchResultItem[] = titleMatches
.slice(0, limit)
.map((match, index) => ({
session: match.session,
matchKind: 'title',
titleMatchIndices: match.indices,
titleScore: match.score,
contentHit: null,
contentHits: [],
rankScore: 2_000_000 + match.score * 100 - index,
}));
return {
query,
results: sortByRequest(results, request.sortBy),
vectorUsed: false,
vectorSkipReason: null,
poolCapped: false,
};
}
export function requestForOrigin(
request: ConversationSearchRequest,
origin: ConversationSearchOrigin,
): ConversationSearchRequest {
return {
...request,
semanticMode: origin.kind === 'remote' ? 'keyword' : request.semanticMode,
filters: {
...request.filters,
sessionIds: origin.sessionIds,
workingDirs: origin.workingDirs ?? null,
},
};
}
export function remoteIndexedSearchIgnoredWorkingDirs(
response: ConversationSearchResponse,
workingDirs: string[] | null | undefined,
): boolean {
const allowed = normalizeWorkingDirSet(workingDirs);
if (allowed == null) return false;
const results = Array.isArray(response?.results) ? response.results : [];
return results.some((item) => !matchesWorkingDirSet(item.session.workingDir, allowed));
}
export function filterResultsByWorkingDirs(
response: ConversationSearchResponse,
workingDirs: string[] | null | undefined,
): ConversationSearchResponse {
return filterResultsByRequestFilters(response, { filters: { workingDirs } });
}
/** Drop remote hits that ignore status / agent / activity / project filters. */
export function filterResultsByRequestFilters(
response: ConversationSearchResponse,
request: Pick<ConversationSearchRequest, 'filters'>,
): ConversationSearchResponse {
const filters = request.filters ?? {};
const allowedDirs = normalizeWorkingDirSet(filters.workingDirs);
const activityCutoff = cutoffForLastActivity(filters.lastActivity ?? 'all');
const status = filters.status ?? 'all';
const agentKind = filters.agentKind ?? 'all';
return {
...response,
results: response.results.filter((item) => {
if (!CINDY_MAKE_ENABLED && isCindyMakeSource(item.session.source)) return false;
if (!matchesWorkingDirSet(item.session.workingDir, allowedDirs)) return false;
if (isOrcaWorkerSession(item.session)) return false;
if (!matchesStatus(item.session.status, status)) return false;
if (agentKind !== 'all' && item.session.agentKind !== agentKind) return false;
if (activityCutoff !== null && sessionActivityMs(item.session) < activityCutoff) {
return false;
}
return true;
}),
};
}
export function shouldReleaseConversationSearchLock(args: {
lockedProjectKey: string | null;
visibleProjects: readonly { projectKey: string }[];
localPlatform: string;
machineSelection?: MachineSelection;
}): boolean {
if (!args.lockedProjectKey) return false;
if (
args.machineSelection != null &&
!lockMatchesMachineSelection(args.lockedProjectKey, args.machineSelection)
) {
return true;
}
// Catalogue still empty (first paint / index not loaded): keep the lock so
// the project-menu fallback session ids / workingDir can apply.
if (args.visibleProjects.length === 0) return false;
const lockedComparison = projectKeyComparisonKey(
args.lockedProjectKey,
args.localPlatform,
);
if (lockedComparison == null) return true;
return !args.visibleProjects.some((project) => {
const comparison = projectKeyComparisonKey(project.projectKey, args.localPlatform);
return comparison != null && comparison === lockedComparison;
});
}
function lockMatchesMachineSelection(
projectKey: string,
selection: MachineSelection,
): boolean {
if (selection === MACHINE_ALL) return true;
const deviceId = deviceIdFromProjectKey(projectKey);
if (deviceId == null) return selection.includes(MACHINE_LOCAL);
return selection.includes(deviceId);
}
function deviceIdFromProjectKey(projectKey: string): string | null {
const normalized = normalizeProjectKey(projectKey);
if (normalized == null || !normalized.startsWith('device:')) return null;
const rest = normalized.slice('device:'.length);
const sep = rest.indexOf(':');
if (sep <= 0) return null;
try {
return decodeURIComponent(rest.slice(0, sep));
} catch {
return null;
}
}
export const LEGACY_REMOTE_SESSION_LIST_LIMIT = LEGACY_REMOTE_LIST_LIMIT;
export function sessionToSearchSummary(session: Session): ConversationSearchSessionSummary {
return {
id: session.id,
title: session.title,
workingDir: session.workingDir,
workspaceKind: session.workspaceKind,
agentKind: session.agentKind,
status: session.status,
source: session.source,
orcaRole: session.orcaRole,
parentSessionId: session.parentSessionId,
userSendAt: session.userSendAt,
updatedAt: session.updatedAt,
createdAt: session.createdAt,
_count: { messages: session._count?.messages ?? 0 },
deviceLinkDeviceId: session.deviceLinkDeviceId ?? null,
deviceLinkDeviceName: session.deviceLinkDeviceName ?? null,
};
}
function normalizeWorkingDirSet(value: string[] | null | undefined): Set<string> | null {
if (value == null || !Array.isArray(value)) return null;
const out = new Set<string>();
for (const item of value) {
const normalized = normalizeWorkingDirForComparison(item);
if (normalized) out.add(normalized);
}
return out.size > 0 ? out : null;
}
function matchesWorkingDirSet(
workingDir: string | null | undefined,
allowed: Set<string> | null,
): boolean {
if (allowed == null) return true;
const key = normalizeWorkingDirForComparison(workingDir);
return key != null && allowed.has(key);
}
function normalizeSessionIds(value: string[] | null | undefined): string[] | null {
if (value == null) return null;
if (!Array.isArray(value)) return null;
const seen = new Set<string>();
const out: string[] = [];
for (const item of value) {
if (typeof item !== 'string') continue;
const trimmed = item.trim();
if (!trimmed || seen.has(trimmed)) continue;
seen.add(trimmed);
out.push(trimmed);
}
return out;
}
function matchesStatus(
status: ConversationSearchSessionStatus | string,
filter: ConversationSearchStatusFilter,
): boolean {
if (status === 'deleted') return false;
if (filter === 'all') return status === 'active' || status === 'archived';
return status === filter;
}
function cutoffForLastActivity(lastActivity: ConversationSearchLastActivityFilter): number | null {
if (lastActivity === 'all') return null;
return Date.now() - LAST_ACTIVITY_DAY_COUNTS[lastActivity] * DAY_MS;
}
function sessionActivityMs(
session: Pick<Session, 'userSendAt' | 'updatedAt'> | ConversationSearchSessionSummary,
): number {
return Math.max(parseActivityMs(session.userSendAt), parseActivityMs(session.updatedAt));
}
function parseActivityMs(value: string | null | undefined): number {
if (!value) return 0;
const ms = Date.parse(value);
return Number.isFinite(ms) ? ms : 0;
}
function clampLimit(value: unknown): number {
if (typeof value !== 'number' || !Number.isFinite(value)) return 24;
return Math.max(1, Math.min(Math.floor(value), 50));
}
function sortByRequest(
results: ConversationSearchResultItem[],
sortBy: ConversationSearchSortBy | undefined,
): ConversationSearchResultItem[] {
return [...results].sort((a, b) => compareSearchResults(a, b, sortBy ?? 'relevance'));
}
function compareSearchResults(
a: ConversationSearchResultItem,
b: ConversationSearchResultItem,
sortBy: ConversationSearchSortBy,
): number {
if (sortBy === 'activityDesc') {
return sessionActivityMs(b.session) - sessionActivityMs(a.session) || relevanceCompare(a, b);
}
if (sortBy === 'activityAsc') {
return sessionActivityMs(a.session) - sessionActivityMs(b.session) || relevanceCompare(a, b);
}
return relevanceCompare(a, b);
}
function relevanceCompare(
a: ConversationSearchResultItem,
b: ConversationSearchResultItem,
): number {
const groupA = a.matchKind === 'title' || a.matchKind === 'both' ? 1 : 0;
const groupB = b.matchKind === 'title' || b.matchKind === 'both' ? 1 : 0;
return (
groupB - groupA ||
b.rankScore - a.rankScore ||
sessionActivityMs(b.session) - sessionActivityMs(a.session) ||
a.session.id.localeCompare(b.session.id)
);
}