Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

2.9 KB
Raw Blame
import type { Principal } from "../types.ts";

const SEARCH_DEFAULT_LIMIT = 20;
const SEARCH_MAX_LIMIT = 100;
type SearchHitType = "message" | "conversation" | "file" | "page" | "external";
export interface BackendSearchHit {
  id: string;
  type: SearchHitType;
  title?: string;
  snippet: string;
  url?: string;
  createdAt?: number;
  score?: number;
  metadata?: Record<string, unknown>;
}
export interface SearchHit extends BackendSearchHit {
  backend: string;
}
interface SearchRequest {
  query: string;
  principals: readonly Principal[];
  limit: number;
}
export interface SearchBackend {
  name: string;
  search(request: SearchRequest): Promise<BackendSearchHit[]>;
}
export interface CoreSearch {
  search(input: {
    query: string;
    principals: readonly Principal[];
    limit?: number;
  }): Promise<{ hits: SearchHit[]; failedBackends: string[] }>;
}
function canonicalPrincipals(principals: readonly Principal[]): Principal[] {
  const unique = new Map<string, Principal>();
  for (const principal of principals) {
    const id = principal.id.trim();
    if (!id) continue;
    const key = id.toLowerCase();
    if (!unique.has(key)) unique.set(key, { ...principal, id });
  }
  return [...unique.values()].sort((a, b) => a.id.localeCompare(b.id));
}
function searchLimit(limit: number | undefined): number {
  if (limit === undefined || !Number.isFinite(limit)) return SEARCH_DEFAULT_LIMIT;
  return Math.max(1, Math.min(SEARCH_MAX_LIMIT, Math.floor(limit)));
}
export function createCoreSearch(
  backends: readonly SearchBackend[],
  opts: { onBackendError?: (backend: string, error: unknown) => void } = {},
): CoreSearch {
  const names = new Set<string>();
  for (const backend of backends) {
    if (!backend.name.trim() || names.has(backend.name))
      throw new Error(`duplicate or empty search backend: ${backend.name}`);
    names.add(backend.name);
  }
  return {
    async search(input) {
      const query = input.query.trim();
      const principals = canonicalPrincipals(input.principals);
      if (!query || !principals.length) return { hits: [], failedBackends: [] };
      const limit = searchLimit(input.limit);
      const settled = await Promise.allSettled(backends.map((backend) => backend.search({ query, principals, limit })));
      const hits: SearchHit[] = [];
      const failedBackends: string[] = [];
      for (const [index, result] of settled.entries()) {
        const backend = backends[index]!;
        if (result.status === "rejected") {
          failedBackends.push(backend.name);
          opts.onBackendError?.(backend.name, result.reason);
          continue;
        }
        for (const hit of result.value.slice(0, limit)) hits.push({ ...hit, backend: backend.name });
      }
      hits.sort((a, b) => (b.score ?? 0) - (a.score ?? 0) || (b.createdAt ?? 0) - (a.createdAt ?? 0));
      return { hits: hits.slice(0, limit), failedBackends };
    },
  };
}