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。

18.8 KB
Raw Blame
/**
 * 手机任务搜索集成层:按设备 fan-out `local-db:conversations:search`,
 * 老端 / 离线回落到已缓存会话的标题与消息预览;项目别名单独补充缓存命中。
 *
 * 纯函数 + 注入依赖,不直接碰 React / store。
 */
import {
  conversationSearchResultKey,
  emptyConversationSearchResponse,
  filterResultsByRequestFilters,
  mergeConversationSearchFanout,
  remoteIndexedSearchIgnoredWorkingDirs,
  remoteConversationSearchRequest,
  stampRemoteSearchResponse,
  type ConversationSearchAgentFilter,
  type ConversationSearchLastActivityFilter,
  type ConversationSearchRequest,
  type ConversationSearchResponse,
  type ConversationSearchResultItem,
  type ConversationSearchSessionSummary,
  type ConversationSearchStatusFilter,
} from '@cindy/maker-shared/conversation-search';
import { stripTrailingPathSeparators } from '@cindy/maker-shared/path-text';
import { resolveProjectAliasForSessions, type ProjectAliasDisplayIndex } from '@cindy/maker-shared/project-alias-sync';
import {
  remoteSessionDisplayTitle,
  sessionRowMessagePreview,
  toRemoteSessionListItem,
  type RemoteSessionListItem,
} from '@cindy/maker-shared/session-list';
import type { DeviceAccessState } from '@cindy/maker-shared/device-list';
import { collapseWorktreeDirForGrouping } from '@cindy/maker-shared/worktree-paths';
import { CINDY_MAKE_ENABLED, isCindyMakeSource } from '@cindy/maker-shared/cindy-make-feature';
import { mobilePresentationLocalizer } from '@/i18n/presentationLocalizer';
import { createMobileMakerTransport } from '@/device-link/mobileMakerTransport';
import { deviceMirrorCleanupDisposition } from '@/device-link/presenceDevices';
import type { RemoteSession } from '@/session/types';

export const CONVERSATION_SEARCH_LIMIT = 24;

export type ConversationSearchInvoke = <T>(
  deviceId: string,
  channel: string,
  args?: unknown[],
) => Promise<T>;

export interface ConversationSearchDeviceOrigin {
  deviceId: string;
  deviceName: string | null;
  reachable: boolean;
  workingDirs?: string[] | null;
}

export interface ConversationSearchDeviceModel {
  canOpen: boolean;
  deviceId: string;
  name: string | null;
  state: DeviceAccessState;
}

/**
 * 搜索源与会话镜像清理边界对齐:
 * - 全部范围:keep / soft(含短暂 offline)进源,hard(撤权 / 关远控)排除;
 * - 单台范围:只保留选中的那台,即使它暂时 offline;
 * - reachable 只看当前能否 invoke,离线或熔断都走缓存回退。
 */
export function conversationSearchOriginsFromDeviceModels(
  devices: readonly ConversationSearchDeviceModel[],
  options: {
    selectedDeviceId?: string | null;
    unresponsiveDeviceIds?: ReadonlySet<string>;
  } = {},
): ConversationSearchDeviceOrigin[] {
  const selectedDeviceId = options.selectedDeviceId ?? null;
  const unresponsiveDeviceIds = options.unresponsiveDeviceIds;
  const targets = selectedDeviceId
    ? devices.filter((item) => item.deviceId === selectedDeviceId)
    : devices.filter((item) => deviceMirrorCleanupDisposition(item.state) !== 'hard');
  return targets.map((item) => ({
    deviceId: item.deviceId,
    deviceName: item.name,
    reachable: item.canOpen && !unresponsiveDeviceIds?.has(item.deviceId),
  }));
}

export interface SearchConversationsAcrossDevicesDeps {
  projectAliases?: ProjectAliasDisplayIndex;
  invoke: ConversationSearchInvoke;
  getCachedSessions: () => readonly RemoteSession[];
  isDeviceUnresponsive?: (deviceId: string) => boolean;
}

export function isConversationSearchChannelNotAllowed(error: unknown): boolean {
  const code = (error as { code?: unknown } | null | undefined)?.code;
  const message = error instanceof Error
    ? error.message
    : typeof error === 'string'
      ? error
      : String(error);
  return `${typeof code === 'string' ? code : ''} ${message}`.includes('CHANNEL_NOT_ALLOWED');
}

export function sessionBelongsToDevice(
  session: Pick<RemoteSession, 'canonicalDeviceId' | 'deviceLinkDeviceId'>,
  deviceId: string,
): boolean {
  return (session.canonicalDeviceId ?? session.deviceLinkDeviceId) === deviceId;
}

export async function searchConversationsAcrossDevices(
  origins: readonly ConversationSearchDeviceOrigin[],
  request: ConversationSearchRequest,
  deps: SearchConversationsAcrossDevicesDeps,
): Promise<ConversationSearchResponse> {
  const query = request.query.trim();
  if (!query || origins.length === 0) return emptyConversationSearchResponse(query);

  const keywordRequest: ConversationSearchRequest = {
    ...request,
    query,
    limit: request.limit ?? CONVERSATION_SEARCH_LIMIT,
    semanticMode: 'keyword',
  };

  const pages = await Promise.all(
    origins.map((origin) => searchOneDevice(origin, keywordRequest, deps)),
  );
  const present = pages.filter((page): page is ConversationSearchResponse => page != null);
  // Updated hosts match aliases before limiting indexed results. Supplement the
  // cache for older/offline hosts, retaining the same visible device/project scope.
  if (deps.projectAliases?.size) {
    // Cache ranks are not comparable to host ranks. Never replace an existing
    // hit (and its message location/metadata) with an alias-only cache projection.
    const existingKeys = new Set(present.flatMap((page) => page.results.map(conversationSearchResultKey)));
    const aliasMatches = deps.getCachedSessions().filter((session) =>
      !existingKeys.has(conversationSearchSessionCacheKey(session)) &&
      session.workspaceKind === 'project' && resolveProjectAliasForSessions([session], deps.projectAliases)
        ?.toLowerCase().includes(query.toLowerCase()));
    for (const origin of origins) present.push(searchCachedDeviceSessions(
      origin, requestForOrigin(origin, keywordRequest), aliasMatches, deps.projectAliases,
    ));
  }
  if (present.length === 0) return emptyConversationSearchResponse(query);

  const merged = mergeConversationSearchFanout(
    present,
    keywordRequest.limit ?? CONVERSATION_SEARCH_LIMIT,
    keywordRequest.sortBy ?? 'relevance',
  );
  return filterResultsByRequestFilters(merged, keywordRequest);
}

async function searchOneDevice(
  origin: ConversationSearchDeviceOrigin,
  request: ConversationSearchRequest,
  deps: SearchConversationsAcrossDevicesDeps,
): Promise<ConversationSearchResponse | null> {
  const unresponsive = deps.isDeviceUnresponsive?.(origin.deviceId) === true;
  if (!origin.reachable || unresponsive) {
    return searchCachedDeviceSessions(origin, requestForOrigin(origin, request), deps.getCachedSessions());
  }

  try {
    const maker = createMobileMakerTransport({
      deviceId: origin.deviceId,
      invoke: deps.invoke,
    });
    const deviceRequest = requestForOrigin(origin, request);
    const raw = await maker.searchConversations(remoteConversationSearchRequest(deviceRequest));
    if (remoteIndexedSearchIgnoredWorkingDirs(raw, deviceRequest.filters?.workingDirs)) {
      return searchCachedDeviceSessions(origin, deviceRequest, deps.getCachedSessions());
    }
    return finalizeRemotePage(raw, origin, deviceRequest);
  } catch (error) {
    return searchCachedDeviceSessions(origin, requestForOrigin(origin, request), deps.getCachedSessions());
  }
}

function finalizeRemotePage(
  response: ConversationSearchResponse,
  origin: ConversationSearchDeviceOrigin,
  request: ConversationSearchRequest,
): ConversationSearchResponse {
  return filterResultsByRequestFilters(
    stampRemoteSearchResponse(response, {
      deviceId: origin.deviceId,
      deviceName: origin.deviceName,
    }),
    request,
  );
}

export function searchCachedDeviceSessions(
  origin: ConversationSearchDeviceOrigin,
  request: ConversationSearchRequest,
  sessions: readonly RemoteSession[],
  projectAliases?: ProjectAliasDisplayIndex,
): ConversationSearchResponse {
  const query = request.query.trim().toLowerCase();
  if (!query) return emptyConversationSearchResponse('');

  const hits: ConversationSearchResultItem[] = [];
  sessions.forEach((session, index) => {
    if (!CINDY_MAKE_ENABLED && isCindyMakeSource(session.source)) return;
    if (!sessionBelongsToDevice(session, origin.deviceId)) return;
    const alias = session.workspaceKind === 'project'
      ? resolveProjectAliasForSessions([session], projectAliases, origin.deviceId ?? undefined) : undefined;
    const match = cachedConversationSearchMatch(session, query, request.unnamedLabel, alias ?? undefined);
    if (!match) return;
    hits.push({
      session: sessionToSearchSummary(session, origin),
      matchKind: match.matchKind,
      titleMatchIndices: [],
      titleScore: null,
      contentHit: null,
      contentHits: [],
      rankScore: 1_000_000 - index,
    });
  });

  return filterResultsByRequestFilters(
    {
      query: request.query.trim(),
      results: hits,
      vectorUsed: false,
      vectorSkipReason: null,
      poolCapped: false,
    },
    request,
  );
}

function cachedConversationSearchMatch(
  session: RemoteSession,
  query: string,
  unnamedLabel?: string,
  projectAlias?: string,
): { matchKind: 'title' | 'content' | 'both' } | null {
  const titleHit = remoteSessionDisplayTitle(session, unnamedLabel).toLowerCase().includes(query)
    || projectAlias?.toLowerCase().includes(query) === true;
  const contentHit = (sessionRowMessagePreview(session) ?? '').toLowerCase().includes(query);
  if (!titleHit && !contentHit) return null;
  if (titleHit && contentHit) return { matchKind: 'both' };
  return { matchKind: titleHit ? 'title' : 'content' };
}

function sessionToSearchSummary(
  session: RemoteSession,
  origin: ConversationSearchDeviceOrigin,
): ConversationSearchSessionSummary {
  return {
    id: session.id,
    title: session.title,
    workingDir: session.workingDir,
    workspaceKind: session.workspaceKind,
    agentKind: session.agentKind,
    status: session.status,
    source: session.source ?? null,
    orcaRole: session.orcaRole === 'lead' || session.orcaRole === 'worker' ? session.orcaRole : null,
    parentSessionId: session.parentSessionId ?? null,
    userSendAt: session.userSendAt,
    updatedAt: session.updatedAt,
    createdAt: session.createdAt,
    _count: { messages: session._count?.messages ?? 0 },
    deviceLinkDeviceId: origin.deviceId,
    deviceLinkDeviceName: origin.deviceName ?? session.deviceLinkDeviceName ?? null,
  };
}

export type ConversationSearchListItem = RemoteSessionListItem & {
  searchFocusClientId?: string;
  searchCompanion?: ConversationSearchSessionSummary['companion'];
  searchLocallyCached: boolean;
};

export function conversationSearchSessionCacheKey(
  session: Pick<RemoteSession, 'id'> & {
    canonicalDeviceId?: string | null;
    deviceLinkDeviceId?: string | null;
  },
): string {
  return `${session.canonicalDeviceId ?? session.deviceLinkDeviceId ?? 'local'}:${session.id}`;
}

/**
 * 索引搜索行只负责打开任务。重命名 / 置顶 / 归档 / 多选写回留在普通列表:
 * 搜索结果是一次请求的投影,订阅 store 再同步筛选只会把写操作家族继续放大。
 * 带 searchLocallyCached 字段 = 搜索命中(无论是否命中本地镜像)。
 */
export function conversationSearchAllowsLocalWrites(item: object): boolean {
  return !('searchLocallyCached' in item);
}

export function cachedSessionForSearchResult(
  item: ConversationSearchResultItem,
  sessionsByCacheKey: ReadonlyMap<string, RemoteSession>,
): RemoteSession | undefined {
  const deviceId = item.session.deviceLinkDeviceId;
  if (!deviceId) return undefined;
  return sessionsByCacheKey.get(`${deviceId}:${item.session.id}`);
}

export function toSearchListItem(
  item: ConversationSearchResultItem,
  now: number,
  unnamedLabel?: string,
  cached?: RemoteSession,
): ConversationSearchListItem {
  const deviceId = item.session.deviceLinkDeviceId ?? cached?.deviceLinkDeviceId;
  const stamped = cached
    ? {
        ...cached,
        canonicalDeviceId: deviceId ?? cached.canonicalDeviceId,
        deviceLinkDeviceId: deviceId,
        deviceLinkDeviceName: item.session.deviceLinkDeviceName ?? cached.deviceLinkDeviceName,
      }
    : {
        id: item.session.id,
        title: item.session.title,
        workingDir: item.session.workingDir,
        workspaceKind: item.session.workspaceKind,
        agentKind: item.session.agentKind,
        status: item.session.status,
        source: item.session.source ?? null,
        orcaRole: item.session.orcaRole,
        userSendAt: item.session.userSendAt,
        updatedAt: item.session.updatedAt,
        createdAt: item.session.createdAt,
        model: '',
        _count: item.session._count,
        deviceLinkDeviceId: item.session.deviceLinkDeviceId,
        deviceLinkDeviceName: item.session.deviceLinkDeviceName,
      };
  const listItem = toRemoteSessionListItem(
    stamped,
    now,
    undefined,
    0,
    item.contentHit?.preview ?? cached?.preview ?? null,
    null,
    unnamedLabel,
    mobilePresentationLocalizer,
  );
  const searchFocusClientId = item.contentHit?.messageClientId?.trim();
  return {
    ...listItem,
    ...(item.session.companion ? {
      title: `${item.session.companion.name} · ${listItem.title}`,
      searchCompanion: item.session.companion,
    } : {}),
    searchLocallyCached: !!cached,
    ...(searchFocusClientId ? { searchFocusClientId } : {}),
  };
}

function requestForOrigin(
  origin: ConversationSearchDeviceOrigin,
  request: ConversationSearchRequest,
): ConversationSearchRequest {
  if (!origin.workingDirs?.length) return request;
  return {
    ...request,
    filters: {
      ...request.filters,
      workingDirs: origin.workingDirs,
    },
  };
}

export type ConversationSearchProjectSelection = 'all' | string[];

export interface ConversationSearchProjectOption {
  count: number;
  deviceId: string;
  deviceName: string | null;
  key: string;
  title: string;
  workingDir: string;
}

export function shouldReplaceListWithSearchResults(
  query: string,
  status: 'idle' | 'searching' | 'ready',
): boolean {
  return query.trim().length > 0 && status === 'ready';
}

export function conversationSearchStatusFilter(
  status: string | undefined,
): ConversationSearchStatusFilter {
  if (status === 'active' || status === 'archived' || status === 'all') return status;
  return 'all';
}

export function conversationSearchActiveFilterCount(input: {
  agentKind?: ConversationSearchAgentFilter;
  lastActivity?: ConversationSearchLastActivityFilter;
  lockedWorkingDirs?: string[] | null;
  projectSelection?: ConversationSearchProjectSelection;
  status?: ConversationSearchStatusFilter;
}): number {
  let count = 0;
  if ((input.status ?? 'all') !== 'all') count += 1;
  if ((input.agentKind ?? 'all') !== 'all') count += 1;
  if ((input.lastActivity ?? 'all') !== 'all') count += 1;
  if (!input.lockedWorkingDirs?.length && input.projectSelection && input.projectSelection !== 'all') {
    count += 1;
  }
  return count;
}

export function nextConversationSearchProjectSelection(
  prev: ConversationSearchProjectSelection,
  projectKey: string,
): ConversationSearchProjectSelection {
  if (prev === 'all') return [projectKey];
  if (prev.includes(projectKey)) {
    const next = prev.filter((key) => key !== projectKey);
    return next.length > 0 ? next : 'all';
  }
  return [...prev, projectKey];
}

export function reconcileConversationSearchProjectSelection(
  selection: ConversationSearchProjectSelection,
  visibleKeys: readonly string[],
): ConversationSearchProjectSelection {
  if (selection === 'all') return 'all';
  const visible = new Set(visibleKeys);
  const next = selection.filter((key) => visible.has(key));
  // Preserve identity when hydration or a host change leaves the selection intact.
  if (next.length === selection.length && next.length > 0) return selection;
  return next.length > 0 ? next : 'all';
}

export function conversationSearchWorkingDirs(input: {
  lockedWorkingDirs?: string[] | null;
}): string[] | null {
  if (input.lockedWorkingDirs?.length) return [...input.lockedWorkingDirs];
  return null;
}

export function scopedConversationSearchOrigins(
  origins: readonly ConversationSearchDeviceOrigin[],
  selection: ConversationSearchProjectSelection,
  projects: readonly ConversationSearchProjectOption[],
): ConversationSearchDeviceOrigin[] {
  if (selection === 'all') return [...origins];
  const selected = new Set(selection);
  const dirsByDevice = new Map<string, string[]>();
  for (const project of projects) {
    if (!selected.has(project.key)) continue;
    const dirs = dirsByDevice.get(project.deviceId) ?? [];
    if (!dirs.includes(project.workingDir)) dirs.push(project.workingDir);
    dirsByDevice.set(project.deviceId, dirs);
  }
  return origins.flatMap((origin) => {
    const dirs = dirsByDevice.get(origin.deviceId);
    if (!dirs?.length) return [];
    return [{ ...origin, workingDirs: dirs }];
  });
}

export function listConversationSearchProjects(
  sessions: readonly Pick<RemoteSession, 'canonicalDeviceId' | 'deviceLinkDeviceId' | 'deviceLinkDeviceName' | 'orcaRole' | 'workingDir' | 'workspaceKind' | 'remoteHostId'>[],
  deviceIds?: ReadonlySet<string>,
  projectAliases?: ProjectAliasDisplayIndex,
): ConversationSearchProjectOption[] {
  const byKey = new Map<string, ConversationSearchProjectOption>();
  const groupedSessions = new Map<string, typeof sessions[number][]>();
  for (const session of sessions) {
    if (session.orcaRole === 'worker') continue;
    if (deviceIds && !sessionBelongsToSelectedDevice(session, deviceIds)) continue;
    if (session.workspaceKind === 'dialogue') continue;
    const deviceId = session.canonicalDeviceId ?? session.deviceLinkDeviceId;
    if (!deviceId) continue;
    const workingDir = stripTrailingPathSeparators(session.workingDir?.trim() ?? '');
    if (!workingDir) continue;
    const dirKey = collapseWorktreeDirForGrouping(workingDir) ?? workingDir;
    const key = `${deviceId}:${dirKey}`;
    const group = groupedSessions.get(key) ?? [];
    group.push(session);
    groupedSessions.set(key, group);
    const existing = byKey.get(key);
    if (existing) {
      existing.count += 1;
      continue;
    }
    byKey.set(key, {
      count: 1,
      deviceId,
      deviceName: session.deviceLinkDeviceName ?? null,
      key,
      title: conversationSearchProjectTitle(dirKey),
      workingDir: dirKey,
    });
  }
  if (projectAliases) {
    for (const [key, project] of byKey) {
      project.title = resolveProjectAliasForSessions(groupedSessions.get(key) ?? [], projectAliases) ?? project.title;
    }
  }
  return [...byKey.values()].sort((a, b) => (
    a.title.localeCompare(b.title) || a.deviceId.localeCompare(b.deviceId) || a.key.localeCompare(b.key)
  ));
}

function sessionBelongsToSelectedDevice(
  session: Pick<RemoteSession, 'canonicalDeviceId' | 'deviceLinkDeviceId'>,
  deviceIds: ReadonlySet<string>,
): boolean {
  const id = session.canonicalDeviceId ?? session.deviceLinkDeviceId;
  return !!id && deviceIds.has(id);
}

function conversationSearchProjectTitle(workingDir: string): string {
  const trimmed = stripTrailingPathSeparators(workingDir);
  const parts = trimmed.split(/[\\/]/).filter(Boolean);
  return parts[parts.length - 1] || workingDir;
}