wiki-graph-core 0.3.1

package/dist/archive/query/lexical-search.js

@@ -0,0 +1,137 @@
+const HAN_RE = new RegExp("\\p{Script=Han}", "u");
+const LATIN_TOKEN_RE = /[\p{Script=Latin}\p{Number}]+/gu;
+const PHRASE_WEIGHT = 2;
+const TERM_WEIGHT = 1;
+function createLexicalQuery(query) {
+  const normalizedQuery = query.trim();
+  if (normalizedQuery === "") {
+    return void 0;
+  }
+  const phraseTerms = splitQueryPhrases(normalizedQuery);
+  const characterTerms = [...normalizedQuery].filter((character) => HAN_RE.test(character)).map((character) => character.toLowerCase());
+  const latinTerms = normalizeLatinTokens(normalizedQuery);
+  const terms = dedupeStrings([
+    ...phraseTerms,
+    ...latinTerms,
+    ...characterTerms
+  ]);
+  if (terms.length === 0) {
+    return void 0;
+  }
+  return {
+    phrases: phraseTerms,
+    terms
+  };
+}
+function listLexicalQueryCandidateTerms(query) {
+  const normalizedQuery = query.trim();
+  return dedupeStrings([
+    ...splitQueryPhrases(normalizedQuery),
+    ...normalizeLatinTokens(normalizedQuery),
+    ...[...normalizedQuery].filter((character) => HAN_RE.test(character)).map((character) => character.toLowerCase())
+  ]);
+}
+function scoreLexicalText(value, query) {
+  const normalizedText = value.toLowerCase();
+  const matchedTerms = [];
+  const missingTerms = [];
+  let score = 0;
+  for (const phrase of query.phrases) {
+    const normalizedPhrase = phrase.toLowerCase();
+    if (normalizedText.includes(normalizedPhrase)) {
+      matchedTerms.push(phrase);
+      score += PHRASE_WEIGHT + countOccurrences(normalizedText, normalizedPhrase);
+    } else if (!missingTerms.includes(phrase)) {
+      missingTerms.push(phrase);
+    }
+  }
+  const latinTokens = new Set(normalizeLatinTokens(value));
+  for (const term of query.terms) {
+    if (matchedTerms.includes(term)) {
+      continue;
+    }
+    const isHan = [...term].every((character) => HAN_RE.test(character));
+    const matched = isHan ? normalizedText.includes(term) : latinTokens.has(term.toLowerCase());
+    if (matched) {
+      matchedTerms.push(term);
+      score += TERM_WEIGHT;
+    } else if (!missingTerms.includes(term)) {
+      missingTerms.push(term);
+    }
+  }
+  if (matchedTerms.length === 0 || score <= 0) {
+    return void 0;
+  }
+  score += calculateCoverageBonus(matchedTerms, query);
+  score += calculateProximityBonus(normalizedText, matchedTerms);
+  return {
+    matchCount: matchedTerms.length,
+    matchedTerms: dedupeStrings(matchedTerms),
+    missingTerms: dedupeStrings(missingTerms).filter(
+      (term) => !matchedTerms.includes(term)
+    ),
+    score,
+    snippetNeedle: selectSnippetNeedle(matchedTerms)
+  };
+}
+function createMentionLexicalHits(mentions, query) {
+  return mentions.map((mention) => {
+    const match = scoreLexicalText(mention.surface, query);
+    return match === void 0 ? void 0 : { match, mention };
+  }).filter(isDefined);
+}
+function splitQueryPhrases(query) {
+  return dedupeStrings(
+    query.split(/\s+/u).map((part) => part.trim()).filter((part) => part.length > 1)
+  );
+}
+function normalizeLatinTokens(value) {
+  return [...value.toLowerCase().matchAll(LATIN_TOKEN_RE)].map(
+    (match) => match[0]
+  );
+}
+function countOccurrences(value, needle) {
+  if (needle === "") {
+    return 0;
+  }
+  let count = 0;
+  let index = value.indexOf(needle);
+  while (index >= 0) {
+    count += 1;
+    index = value.indexOf(needle, index + needle.length);
+  }
+  return count;
+}
+function calculateCoverageBonus(matchedTerms, query) {
+  const total = query.terms.length;
+  if (total === 0) {
+    return 0;
+  }
+  return matchedTerms.length / total;
+}
+function calculateProximityBonus(normalizedText, matchedTerms) {
+  const positions = matchedTerms.map((term) => normalizedText.indexOf(term.toLowerCase())).filter((position) => position >= 0).sort((left, right) => left - right);
+  if (positions.length < 2) {
+    return 0;
+  }
+  const span = positions.at(-1) - positions[0];
+  return span <= 80 ? 1 : span <= 240 ? 0.5 : 0;
+}
+function selectSnippetNeedle(matchedTerms) {
+  return [...matchedTerms].sort(
+    (left, right) => right.length - left.length
+  )[0];
+}
+function dedupeStrings(values) {
+  return [...new Set(values.filter((value) => value !== ""))];
+}
+function isDefined(value) {
+  return value !== void 0;
+}
+export {
+  createLexicalQuery,
+  createMentionLexicalHits,
+  listLexicalQueryCandidateTerms,
+  scoreLexicalText
+};
+//# sourceMappingURL=lexical-search.js.map

package/dist/archive/query/lexical-search.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/archive/query/lexical-search.ts"],"sourcesContent":["export interface LexicalQuery {\n  readonly phrases: readonly string[];\n  readonly terms: readonly string[];\n}\n\nexport interface LexicalScore {\n  readonly matchCount: number;\n  readonly matchedTerms: readonly string[];\n  readonly missingTerms: readonly string[];\n  readonly score: number;\n  readonly snippetNeedle: string;\n}\n\nconst HAN_RE = /\\p{Script=Han}/u;\nconst LATIN_TOKEN_RE = /[\\p{Script=Latin}\\p{Number}]+/gu;\nconst PHRASE_WEIGHT = 2;\nconst TERM_WEIGHT = 1;\n\nexport function createLexicalQuery(query: string): LexicalQuery | undefined {\n  const normalizedQuery = query.trim();\n\n  if (normalizedQuery === \"\") {\n    return undefined;\n  }\n\n  const phraseTerms = splitQueryPhrases(normalizedQuery);\n  const characterTerms = [...normalizedQuery]\n    .filter((character) => HAN_RE.test(character))\n    .map((character) => character.toLowerCase());\n  const latinTerms = normalizeLatinTokens(normalizedQuery);\n  const terms = dedupeStrings([\n    ...phraseTerms,\n    ...latinTerms,\n    ...characterTerms,\n  ]);\n\n  if (terms.length === 0) {\n    return undefined;\n  }\n\n  return {\n    phrases: phraseTerms,\n    terms,\n  };\n}\n\nexport function listLexicalQueryCandidateTerms(\n  query: string,\n): readonly string[] {\n  const normalizedQuery = query.trim();\n\n  return dedupeStrings([\n    ...splitQueryPhrases(normalizedQuery),\n    ...normalizeLatinTokens(normalizedQuery),\n    ...[...normalizedQuery]\n      .filter((character) => HAN_RE.test(character))\n      .map((character) => character.toLowerCase()),\n  ]);\n}\n\nexport function scoreLexicalText(\n  value: string,\n  query: LexicalQuery,\n): LexicalScore | undefined {\n  const normalizedText = value.toLowerCase();\n  const matchedTerms: string[] = [];\n  const missingTerms: string[] = [];\n  let score = 0;\n\n  for (const phrase of query.phrases) {\n    const normalizedPhrase = phrase.toLowerCase();\n\n    if (normalizedText.includes(normalizedPhrase)) {\n      matchedTerms.push(phrase);\n      score +=\n        PHRASE_WEIGHT + countOccurrences(normalizedText, normalizedPhrase);\n    } else if (!missingTerms.includes(phrase)) {\n      missingTerms.push(phrase);\n    }\n  }\n\n  const latinTokens = new Set(normalizeLatinTokens(value));\n\n  for (const term of query.terms) {\n    if (matchedTerms.includes(term)) {\n      continue;\n    }\n\n    const isHan = [...term].every((character) => HAN_RE.test(character));\n    const matched = isHan\n      ? normalizedText.includes(term)\n      : latinTokens.has(term.toLowerCase());\n\n    if (matched) {\n      matchedTerms.push(term);\n      score += TERM_WEIGHT;\n    } else if (!missingTerms.includes(term)) {\n      missingTerms.push(term);\n    }\n  }\n\n  if (matchedTerms.length === 0 || score <= 0) {\n    return undefined;\n  }\n\n  score += calculateCoverageBonus(matchedTerms, query);\n  score += calculateProximityBonus(normalizedText, matchedTerms);\n\n  return {\n    matchCount: matchedTerms.length,\n    matchedTerms: dedupeStrings(matchedTerms),\n    missingTerms: dedupeStrings(missingTerms).filter(\n      (term) => !matchedTerms.includes(term),\n    ),\n    score,\n    snippetNeedle: selectSnippetNeedle(matchedTerms),\n  };\n}\n\nexport function createMentionLexicalHits<\n  T extends { readonly surface: string },\n>(\n  mentions: readonly T[],\n  query: LexicalQuery,\n): readonly {\n  readonly match: LexicalScore;\n  readonly mention: T;\n}[] {\n  return mentions\n    .map((mention) => {\n      const match = scoreLexicalText(mention.surface, query);\n\n      return match === undefined ? undefined : { match, mention };\n    })\n    .filter(isDefined);\n}\n\nfunction splitQueryPhrases(query: string): readonly string[] {\n  return dedupeStrings(\n    query\n      .split(/\\s+/u)\n      .map((part) => part.trim())\n      .filter((part) => part.length > 1),\n  );\n}\n\nfunction normalizeLatinTokens(value: string): readonly string[] {\n  return [...value.toLowerCase().matchAll(LATIN_TOKEN_RE)].map(\n    (match) => match[0],\n  );\n}\n\nfunction countOccurrences(value: string, needle: string): number {\n  if (needle === \"\") {\n    return 0;\n  }\n\n  let count = 0;\n  let index = value.indexOf(needle);\n\n  while (index >= 0) {\n    count += 1;\n    index = value.indexOf(needle, index + needle.length);\n  }\n\n  return count;\n}\n\nfunction calculateCoverageBonus(\n  matchedTerms: readonly string[],\n  query: LexicalQuery,\n): number {\n  const total = query.terms.length;\n\n  if (total === 0) {\n    return 0;\n  }\n\n  return matchedTerms.length / total;\n}\n\nfunction calculateProximityBonus(\n  normalizedText: string,\n  matchedTerms: readonly string[],\n): number {\n  const positions = matchedTerms\n    .map((term) => normalizedText.indexOf(term.toLowerCase()))\n    .filter((position) => position >= 0)\n    .sort((left, right) => left - right);\n\n  if (positions.length < 2) {\n    return 0;\n  }\n\n  const span = positions.at(-1)! - positions[0]!;\n\n  return span <= 80 ? 1 : span <= 240 ? 0.5 : 0;\n}\n\nfunction selectSnippetNeedle(matchedTerms: readonly string[]): string {\n  return [...matchedTerms].sort(\n    (left, right) => right.length - left.length,\n  )[0]!;\n}\n\nfunction dedupeStrings(values: readonly string[]): readonly string[] {\n  return [...new Set(values.filter((value) => value !== \"\"))];\n}\n\nfunction isDefined<T>(value: T | undefined): value is T {\n  return value !== undefined;\n}\n"],"mappings":"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","names":[]}

package/dist/archive/query/search-cache.d.ts

@@ -0,0 +1,192 @@
+import { GcContext, GcJobResult } from '../../gc/types.js';
+import { j as ArchiveFindHit } from '../../index-B8NNnQ8P.js';
+import '../../document/database.js';
+import 'sqlite3';
+import '../../document/document.js';
+import '../../source/meta.js';
+import 'zod';
+import '../../source/toc.js';
+import '../../source/types.js';
+import '../../document/text-streams.js';
+import '../../document/types.js';
+import '../../document/stores.js';
+import '../../wikipage/types.js';
+import '../../facade/graph.js';
+import '../../facade/chapter.js';
+import '../../common/language.js';
+import '../../common/llm-scope.js';
+import '../../llm/client.js';
+import '../../llm/context.js';
+import '../../llm/cache.js';
+import '../../llm/types.js';
+import 'ai';
+import '../../reader/types.js';
+import '../../reader/attention/attention.js';
+import '../../reader/chunk-batch/types.js';
+import '../../reader/segment/types.js';
+import '../../serial.js';
+
+interface SearchSessionInput {
+    readonly archiveKey: string;
+    readonly chapters: readonly number[] | null;
+    readonly chunkHits?: readonly SearchChunkHitInput[];
+    readonly entityHits?: readonly SearchEntityHitInput[];
+    readonly evidenceEvents?: readonly SearchEvidenceHitEventInput[];
+    readonly items?: readonly ArchiveFindHit[];
+    readonly lens: string;
+    readonly match: string;
+    readonly order: string;
+    readonly query: string;
+    readonly revisionScope: string;
+    readonly terms: readonly string[];
+    readonly tripleHits?: readonly SearchTripleHitInput[];
+    readonly types: readonly string[] | null;
+}
+declare const SEARCH_EVIDENCE_KIND: {
+    readonly mention: 1;
+    readonly mentionLink: 2;
+    readonly chunk: 3;
+};
+type SearchEvidenceKind = (typeof SEARCH_EVIDENCE_KIND)[keyof typeof SEARCH_EVIDENCE_KIND];
+interface SearchEvidenceHitEventInput {
+    readonly chapterId: number;
+    readonly evidenceId: string;
+    readonly evidenceKind: SearchEvidenceKind;
+    readonly score: number;
+    readonly sentenceIndex: number;
+}
+interface SearchEntityHitInput {
+    readonly evidenceTopScores?: readonly number[];
+    readonly propertyTopScores?: readonly number[];
+    readonly qid: string;
+}
+interface SearchTripleHitInput {
+    readonly evidenceTopScores: readonly number[];
+    readonly objectQid: string;
+    readonly predicate: string;
+    readonly subjectQid: string;
+}
+interface SearchChunkHitInput {
+    readonly chunkId: number;
+    readonly evidenceTopScores?: readonly number[];
+    readonly propertyTopScores?: readonly number[];
+}
+interface EntitySearchSessionInput {
+    readonly archiveKey: string;
+    readonly chapters: readonly number[] | null;
+    readonly chunkHits?: readonly SearchChunkHitInput[];
+    readonly entityHits?: readonly SearchEntityHitInput[];
+    readonly evidenceEvents?: readonly SearchEvidenceHitEventInput[];
+    readonly lens: string;
+    readonly match: string;
+    readonly order: string;
+    readonly query: string;
+    readonly revisionScope: string;
+    readonly terms: readonly string[];
+    readonly tripleHits?: readonly SearchTripleHitInput[];
+    readonly types: readonly string[] | null;
+}
+interface SearchSessionPage {
+    readonly chapters: readonly number[] | null;
+    readonly items: readonly ArchiveFindHit[];
+    readonly lens: string;
+    readonly match: string;
+    readonly nextCursor: string | null;
+    readonly query: string;
+    readonly sessionId: string;
+    readonly terms: readonly string[];
+    readonly types: readonly string[] | null;
+}
+interface EntitySearchSessionPage {
+    readonly chapters: readonly number[] | null;
+    readonly items: readonly ArchiveFindHit[];
+    readonly lens: string;
+    readonly match: string;
+    readonly nextCursor: string | null;
+    readonly query: string;
+    readonly sessionId: string;
+    readonly terms: readonly string[];
+    readonly types: readonly string[] | null;
+}
+interface SearchSessionDescriptor {
+    readonly chapters: readonly number[] | null;
+    readonly createdAt: number;
+    readonly lens: string;
+    readonly match: string;
+    readonly objectCachesPopulated: boolean;
+    readonly query: string;
+    readonly sessionId: string;
+    readonly terms: readonly string[];
+    readonly types: readonly string[] | null;
+}
+type BucketSearchCursor = {
+    readonly bucket: 0;
+    readonly key?: SearchChapterTitleCursorKey;
+} | {
+    readonly bucket: 1;
+    readonly key?: SearchObjectCursorKey;
+} | {
+    readonly bucket: 2;
+    readonly key?: SearchChunkCursorKey;
+} | {
+    readonly bucket: 3;
+    readonly key?: SearchTextCursorKey;
+};
+interface SearchChapterTitleCursorKey {
+    readonly chapterId: number;
+    readonly score: number;
+}
+interface SearchObjectCursorKey {
+    readonly id: string;
+    readonly kind: "entity" | "triple";
+    readonly score: number;
+}
+interface SearchChunkCursorKey {
+    readonly chunkId: number;
+    readonly score: number;
+}
+interface SearchTextCursorKey {
+    readonly chapterId: number;
+    readonly kind: number;
+    readonly rank: number;
+    readonly sentenceIndex: number;
+}
+type SearchSessionCacheInput = Omit<SearchSessionInput, "items">;
+type EntitySearchSessionCacheInput = EntitySearchSessionInput;
+declare function readCachedSearchSessionPage(input: SearchSessionCacheInput, offset: number, limit: number): Promise<SearchSessionPage | undefined>;
+declare function readCachedEntitySearchSessionPage(input: EntitySearchSessionCacheInput, offset: number, limit: number): Promise<EntitySearchSessionPage | undefined>;
+declare function createSearchSession(input: SearchSessionInput): Promise<string>;
+declare function readSearchSessionObjectBucketPage(sessionId: string, bucket: 1, after: SearchObjectCursorKey | undefined, limit: number): Promise<readonly ArchiveFindHit[]>;
+declare function readSearchSessionChunkBucketPage(sessionId: string, after: SearchChunkCursorKey | undefined, limit: number): Promise<readonly ArchiveFindHit[]>;
+declare function createEntitySearchSession(input: EntitySearchSessionInput): Promise<string>;
+declare function populateSearchSessionObjectCaches(input: {
+    readonly chunkHits?: readonly SearchChunkHitInput[];
+    readonly entityHits?: readonly SearchEntityHitInput[];
+    readonly evidenceEvents?: readonly SearchEvidenceHitEventInput[];
+    readonly sessionId: string;
+    readonly tripleHits?: readonly SearchTripleHitInput[];
+}): Promise<void>;
+declare function deleteArchiveSearchSessions(archiveKey: string): Promise<void>;
+declare function runSearchCacheGc(context: GcContext): Promise<GcJobResult>;
+declare function readSearchSessionPage(sessionId: string, offset: number, limit: number, expectedArchiveKey?: string, expectedCreatedAt?: number): Promise<SearchSessionPage>;
+declare function readEntitySearchSessionPage(sessionId: string, offset: number, limit: number, expectedArchiveKey?: string, expectedCreatedAt?: number): Promise<EntitySearchSessionPage>;
+declare function readSearchSessionDescriptor(sessionId: string, expectedArchiveKey?: string): Promise<SearchSessionDescriptor>;
+declare function readSearchSessionMetadataForCursor(sessionId: string, expectedArchiveKey?: string, expectedCreatedAt?: number): Promise<SearchSessionDescriptor>;
+declare function readEntitySearchEvidenceMentions(sessionId: string, mentionIds: readonly string[], limit: number): Promise<readonly {
+    readonly mentionId: string;
+    readonly score: number;
+}[]>;
+declare function encodeSearchSessionCursor(sessionId: string, offset: number, createdAt: number): string;
+declare function encodeBucketSearchSessionCursor(sessionId: string, cursor: BucketSearchCursor, createdAt: number): string;
+declare function decodeBucketSearchSessionCursor(cursor: string): {
+    readonly createdAt: number;
+    readonly cursor: BucketSearchCursor;
+    readonly sessionId: string;
+};
+declare function decodeSearchSessionCursor(cursor: string): {
+    readonly createdAt?: number;
+    readonly offset: number;
+    readonly sessionId: string;
+};
+
+export { type BucketSearchCursor, type EntitySearchSessionInput, type EntitySearchSessionPage, SEARCH_EVIDENCE_KIND, type SearchChapterTitleCursorKey, type SearchChunkCursorKey, type SearchChunkHitInput, type SearchEntityHitInput, type SearchEvidenceHitEventInput, type SearchEvidenceKind, type SearchObjectCursorKey, type SearchSessionDescriptor, type SearchSessionInput, type SearchSessionPage, type SearchTextCursorKey, type SearchTripleHitInput, createEntitySearchSession, createSearchSession, decodeBucketSearchSessionCursor, decodeSearchSessionCursor, deleteArchiveSearchSessions, encodeBucketSearchSessionCursor, encodeSearchSessionCursor, populateSearchSessionObjectCaches, readCachedEntitySearchSessionPage, readCachedSearchSessionPage, readEntitySearchEvidenceMentions, readEntitySearchSessionPage, readSearchSessionChunkBucketPage, readSearchSessionDescriptor, readSearchSessionMetadataForCursor, readSearchSessionObjectBucketPage, readSearchSessionPage, runSearchCacheGc };