@wirecat/cli-core 0.390.0 → 0.391.0

package/dist/search/lucene/types.js

@@ -15,6 +15,10 @@ export const SEARCH_QUERY = {
     command: "search",
     guide: "https://github.com/WireCatLabs/cli-core/blob/main/docs/search/query-language.md",
 };
+/** How message search parses typed text: `"a b"~N` is words at most N apart; notes still refuse `~`. */
+export const MESSAGE_PARSING = { ...SEARCH_QUERY, proximity: true };
+/** Further apart than this, two words are rarely about one thing, even in a long message. */
+export const MOST_WORDS_APART = 50;
 export function searchError(reason, span, alternative) {
     queryError(reason, span, alternative, SEARCH_QUERY);
 }

package/dist/search/question-plan.js

@@ -1,6 +1,6 @@
 import { implicitTextTerms, parseLucene, walkQuery } from "@wirecat/cli-base/query";
 import { normalize } from "../store/normalize.js";
-import { SEARCH_QUERY } from "./lucene/types.js";
+import { MESSAGE_PARSING } from "./lucene/types.js";
 export const words = (text) => normalize(text).match(/[\p{L}\p{N}]+/gu) ?? [];
 const scaffolding = new Set(words("what which how many much who where when is are was were do does did can could should we the a an for of to under from in on at has have сколько какой какая какие какое кто кому кем где когда как что во по на в к с у через ли должен должна нужно идёт идет можно может могут"));
 const questionWord = /\b(?:what|which|how|who|where|when|can|could|should)\b|(?:^|\s)(?:сколько|какой|какая|какие|какое|кто|кому|кем|где|когда|как|что|можно|может|могут|ли)(?:\s|$)/iu;
@@ -27,7 +27,7 @@ export function planQuestion(text, strict = false) {
             removed: [],
             aliases: [],
         };
-    const inputAst = parseLucene(text, SEARCH_QUERY);
+    const inputAst = parseLucene(text, MESSAGE_PARSING);
     const rawTextual = walkQuery(inputAst.root).filter((node) => node.field === "text" || node.field === "exact");
     const body = rawTextual.map((node) => node.value).join(" ");
     const prefix = words(body).slice(0, 2);
@@ -66,7 +66,7 @@ export function planQuestion(text, strict = false) {
         if (last?.operator === "wildcard" && text[mark] === "?")
             cleaned = text.slice(0, mark) + text.slice(mark + 1);
     }
-    const ast = cleaned === text ? inputAst : parseLucene(cleaned, SEARCH_QUERY);
+    const ast = cleaned === text ? inputAst : parseLucene(cleaned, MESSAGE_PARSING);
     const predicates = walkQuery(ast.root);
     const textual = predicates.filter((p) => p.field === "text" || p.field === "exact");
     const fields = predicates.filter((p) => p.field !== "text" && p.field !== "exact");

package/dist/services/excerpt.js

@@ -3,7 +3,10 @@ import { fold } from "../store/normalize.js";
 export const queryWords = (query) => query
     .toLowerCase()
     .split(/\s+/)
-    .map((word) => word.replace(/^[\p{L}_]+:/u, "").replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, ""))
+    .map((word) => word
+    .replace(/^[\p{L}_]+:/u, "")
+    .replace(/~\d+$/u, "")
+    .replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, ""))
     .filter((word) => word.length > 2 && !["and", "or", "not"].includes(word));
 /**
  * About `size` characters of `text` on one line, around the first word of `query` it holds, or its start when it

package/dist/services/index.d.ts

@@ -65,8 +65,10 @@ export type { InboxService } from "./inbox.js";
 export { inboxService } from "./inbox.js";
 export { readMail } from "./mail-search.js";
 export { type MeetingHitSearchRequest, refreshMeetingIndex, searchMeetingHits } from "./meeting-hit-search.js";
+export { type MeetingLink, type MeetingLinksRequest, readMeetingLinks } from "./meeting-links.js";
 export { createMeetingProjectCandidateReader } from "./meeting-project-candidates.js";
 export { readMeetingProjectDiscovery } from "./meeting-project-discovery.js";
+export { type MeetingReviewRequest, readMeetingReview } from "./meeting-review.js";
 export { type MeetingStatsRequest, readMeetingStats } from "./meeting-stats.js";
 export { chatIdIn, storedChatId } from "./message-resolution.js";
 export type { AroundWindow, FoundMessage, ListWindow, MessagesService, MessageTarget, Pinned, Reacted, SearchFound, SearchQuery, SendRequest, Starred, } from "./messages.js";

package/dist/services/index.js

@@ -46,8 +46,10 @@ export { foldersService } from "./folders.js";
 export { inboxService } from "./inbox.js";
 export { readMail } from "./mail-search.js";
 export { refreshMeetingIndex, searchMeetingHits } from "./meeting-hit-search.js";
+export { readMeetingLinks } from "./meeting-links.js";
 export { createMeetingProjectCandidateReader } from "./meeting-project-candidates.js";
 export { readMeetingProjectDiscovery } from "./meeting-project-discovery.js";
+export { readMeetingReview } from "./meeting-review.js";
 export { readMeetingStats } from "./meeting-stats.js";
 export { chatIdIn, storedChatId } from "./message-resolution.js";
 export { DELETE_AT_ONCE, messagesService } from "./messages.js";

package/dist/services/meeting-links.d.ts

@@ -0,0 +1,33 @@
+import type { MeetingChatLinesInput, MeetingHitSearchRequest } from "../meetings/index.js";
+import type { MessageStore } from "../store/store.js";
+export type MeetingLinksRequest = Omit<MeetingHitSearchRequest, "limit" | "after" | "maxReadBytes"> & Pick<MeetingChatLinesInput, "maxMessages">;
+/** One link as the meetings' chat holds it: where and how often it was shared. */
+export interface MeetingLink {
+    url: string;
+    domain: string | null;
+    /** The Google Docs, Sheets, Slides, Forms or Drive file it names. */
+    documentId: string | null;
+    count: number;
+    firstAt: number;
+    lastAt: number;
+    senders: string[];
+    meetings: {
+        meetingId: number;
+        accountId: number;
+        title: string | null;
+    }[];
+}
+/** Links shared in the chat of the selected meetings, most shared first; found when read, not stored. */
+export declare const readMeetingLinks: (store: Pick<MessageStore, "meetings"> & {
+    knowledge?: MessageStore["knowledge"];
+}, request: MeetingLinksRequest) => Promise<{
+    items: MeetingLink[];
+    messages: number;
+    meetings: number;
+    selection: {
+        kind: import("../store/index.js").VocabularyKind;
+        id: number;
+        name: string;
+        by: "explicit-link";
+    }[];
+}>;

package/dist/services/meeting-links.js

@@ -0,0 +1,41 @@
+import { googleDocumentId } from "../domain/google-documents.js";
+import { findMentions } from "../domain/mentions.js";
+import { resolveMeetingSelection } from "./meeting-hit-search.js";
+/** Links shared in the chat of the selected meetings, most shared first; found when read, not stored. */
+export const readMeetingLinks = async (store, request) => {
+    const { maxMessages, ...selecting } = request;
+    const { input, selection } = await resolveMeetingSelection(store, selecting);
+    const lines = await store.meetings.meetingChatLines({
+        ...input,
+        ...(maxMessages === undefined ? {} : { maxMessages }),
+    });
+    const links = new Map();
+    for (const line of lines)
+        for (const found of findMentions(line.text)) {
+            if (found.kind !== "url")
+                continue;
+            const link = links.get(found.value) ?? {
+                url: found.value,
+                domain: found.domain,
+                documentId: googleDocumentId(found.value),
+                count: 0,
+                firstAt: line.sentAt,
+                lastAt: line.sentAt,
+                senders: [],
+                meetings: [],
+            };
+            link.count += 1;
+            link.lastAt = line.sentAt;
+            if (line.sender !== null && !link.senders.includes(line.sender))
+                link.senders.push(line.sender);
+            if (!link.meetings.some((one) => one.meetingId === line.meetingId))
+                link.meetings.push({ meetingId: line.meetingId, accountId: line.accountId, title: line.title });
+            links.set(found.value, link);
+        }
+    return {
+        items: [...links.values()].sort((a, b) => b.count - a.count || b.lastAt - a.lastAt),
+        messages: lines.length,
+        meetings: new Set(lines.map((line) => line.meetingId)).size,
+        selection,
+    };
+};

package/dist/services/meeting-review.d.ts

@@ -0,0 +1,12 @@
+import type { MeetingHitSearchRequest, MeetingReview } from "../meetings/index.js";
+import type { MessageStore } from "../store/store.js";
+import { resolveMeetingSelection } from "./meeting-hit-search.js";
+export type MeetingReviewRequest = Omit<MeetingHitSearchRequest, "limit" | "after" | "maxReadBytes"> & {
+    limit?: number;
+};
+/** The newest meetings of the selection with their summaries, talk and projects; names resolved as search does. */
+export declare const readMeetingReview: (store: Pick<MessageStore, "meetings"> & {
+    knowledge?: MessageStore["knowledge"];
+}, request: MeetingReviewRequest) => Promise<MeetingReview & {
+    selection: Awaited<ReturnType<typeof resolveMeetingSelection>>["selection"];
+}>;

package/dist/services/meeting-review.js

@@ -0,0 +1,8 @@
+import { resolveMeetingSelection } from "./meeting-hit-search.js";
+/** The newest meetings of the selection with their summaries, talk and projects; names resolved as search does. */
+export const readMeetingReview = async (store, request) => {
+    const { limit, ...selecting } = request;
+    const { input, selection } = await resolveMeetingSelection(store, selecting);
+    const review = await store.meetings.meetingReview({ ...input, ...(limit === undefined ? {} : { limit }) });
+    return { ...review, selection };
+};

package/dist/services/messages-search.js

@@ -14,7 +14,7 @@ import { chatAmong, senderAmong } from "./message-resolution.js";
 import { accountsOfKind, listedAccounts, MAIL } from "./search-kind.js";
 const MAIL_FIELDS = new Set(["to", "cc", "bcc", "subject", "mailbox", "label", "is"]);
 import { dateRange, parseLucene, timezoneOf, walkQuery } from "@wirecat/cli-base/query";
-import { SEARCH_QUERY, searchError } from "../search/lucene/types.js";
+import { MESSAGE_PARSING, searchError } from "../search/lucene/types.js";
 const positiveSources = (node) => node.kind === "predicate"
     ? node.field === "in"
         ? [node.value.toLowerCase()]
@@ -47,7 +47,7 @@ export const prepareLucene = async (store, account, request, messenger) => {
                     span: { start: 0, end: 0 },
                 },
             }
-            : validateFields(parseLucene(request.text, { ...SEARCH_QUERY, defaultField: request.exact ? "exact" : "text" }));
+            : validateFields(parseLucene(request.text, { ...MESSAGE_PARSING, defaultField: request.exact ? "exact" : "text" }));
     const timezone = timezoneOf(request.timezone);
     const stored = await store.accounts.accounts();
     // A fresh store has no row yet for the account it runs as; "every account" still means that one.

package/dist/services/searches.js

@@ -1,7 +1,7 @@
 import { CliError, singleLine } from "@wirecat/cli-base";
 import { parseLucene } from "@wirecat/cli-base/query";
 import { validateAst, validateFields } from "../search/lucene/registry.js";
-import { SEARCH_QUERY } from "../search/lucene/types.js";
+import { MESSAGE_PARSING } from "../search/lucene/types.js";
 import { isAdminSelection, readAdminSelection } from "./admin-statistics.js";
 import { searchRecordOf } from "./search-record.js";
 /** A saved search or a run as every searches command answers it. */
@@ -31,7 +31,7 @@ const checked = (params) => {
     if (params.ast !== undefined)
         validateAst(params.ast);
     else if (params.text !== undefined)
-        validateFields(parseLucene(params.text, { ...SEARCH_QUERY, defaultField: params.exact ? "exact" : "text" }));
+        validateFields(parseLucene(params.text, { ...MESSAGE_PARSING, defaultField: params.exact ? "exact" : "text" }));
     return params;
 };
 const named = (search, check) => {
@@ -52,7 +52,7 @@ const both = (stored, words) => ({
         kind: "boolean",
         clauses: [
             { occur: "must", node: stored.root },
-            { occur: "must", node: parseLucene(words, SEARCH_QUERY).root },
+            { occur: "must", node: parseLucene(words, MESSAGE_PARSING).root },
         ],
         span: { start: 0, end: 0 },
     },

package/dist/store/sqlite/lucene-fields.d.ts

@@ -32,6 +32,8 @@ export interface Corpus {
 /** A voice note's transcript is its attachment's text, written by speech recognition (`speech:<model>`). */
 export declare const SPEECH = "coalesce(att.extractor,'') LIKE 'speech:%'";
 export declare const quoted: (value: string) => string;
+/** A leaf's words as an FTS5 match: a phrase, or with `~N` its words at most N apart, in any order. */
+export declare const ftsMatch: (node: ResolvedPredicate) => string;
 export declare const combine: (parts: Fragment[], operator: "AND" | "OR") => Fragment;
 export declare const prefixOf: (pattern: string) => string;
 export declare const wordMatch: (corpus: Corpus, match: string) => Fragment;
@@ -50,7 +52,7 @@ export interface FieldScope {
         sql: string;
         params: SqlValue[];
     };
-    everywhere: (node: ResolvedPredicate, text: string, fragment: Fragment) => Fragment;
+    everywhere: (node: ResolvedPredicate, fragment: Fragment) => Fragment;
     /** Counts the patterns' expanded words against the query's budget. */
     expand: (count: number) => number;
 }

package/dist/store/sqlite/lucene-fields.js

@@ -8,12 +8,20 @@ import { parseBytes } from "../../search/lucene/registry.js";
 import { isStemmed } from "../../search/lucene/resolved.js";
 import { exhausted, QUERY_LIMITS, searchError } from "../../search/lucene/types.js";
 import { inSource } from "../../search/query.js";
+import { STEM_SEPARATOR } from "../../search/stem.js";
 import { normalize } from "../normalize.js";
 import { linkMatch } from "./mention-links.js";
 import { valueMatch } from "./phone-countries.js";
 /** A voice note's transcript is its attachment's text, written by speech recognition (`speech:<model>`). */
 export const SPEECH = "coalesce(att.extractor,'') LIKE 'speech:%'";
 export const quoted = (value) => `"${value.replaceAll('"', '""')}"`;
+/** A leaf's words as an FTS5 match: a phrase, or with `~N` its words at most N apart, in any order. */
+export const ftsMatch = (node) => {
+    const text = normalize(node.value);
+    const words = node.slop === undefined ? [] : (text.match(/[\p{L}\p{N}\p{Co}\p{M}]+/gu) ?? []);
+    return words.length > 1 ? nearMatch(words, node.slop) : quoted(text);
+};
+const nearMatch = (words, apart) => `NEAR(${words.map(quoted).join(" ")}, ${apart})`;
 export const combine = (parts, operator) => ({
     sql: parts.length ? `(${parts.map(({ sql }) => sql).join(` ${operator} `)})` : operator === "AND" ? "1" : "0",
     params: parts.flatMap(({ params }) => params),
@@ -59,20 +67,79 @@ const mentioned = ({ mail }, where, params) => mail
     : bound(`m.id IN (SELECT mn.source_id FROM mentions mn WHERE mn.source_type='message' AND ${where} ` +
         "UNION SELECT a.attachable_id FROM mentions mn JOIN attachments a ON a.id=mn.source_id " +
         `AND a.attachable_type='message' WHERE mn.source_type='attachment' AND ${where})`, ...params, ...params);
-const stemsOf = ({ execution }, text) => execution.stemmer?.phrases(text);
+const stemsOf = ({ execution: { stemmer } }, node) => {
+    if (node.slop === undefined)
+        return stemmer?.phrases(node.value);
+    const sequences = (stemmer?.stemSequences(node.value) ?? []).filter((sequence) => sequence.length);
+    return sequences.length
+        ? sequences
+            .map((sequence) => (sequence.length > 1 ? nearMatch(sequence, node.slop) : quoted(sequence.join(""))))
+            .join(" OR ")
+        : undefined;
+};
+/** Whether some stem sequence of a text holds every stem of `wanted` with at most `apart` other words between. */
+const near = (sequence, wanted, apart) => {
+    const events = sequence.flatMap((stem, index) => (wanted.includes(stem) ? [{ index, stem }] : []));
+    const held = new Map();
+    const distinct = new Set(wanted).size;
+    let left = 0;
+    for (const event of events) {
+        held.set(event.stem, (held.get(event.stem) ?? 0) + 1);
+        while (held.size === distinct) {
+            const first = events[left];
+            if (event.index - first.index + 1 - distinct <= apart)
+                return true;
+            const count = (held.get(first.stem) ?? 1) - 1;
+            if (count)
+                held.set(first.stem, count);
+            else
+                held.delete(first.stem);
+            left++;
+        }
+    }
+    return false;
+};
+/**
+ * `NEAR` over the stems can bridge `STEM_SEPARATOR`, which parts a text's Latin readings: the end of one and the
+ * start of the next are one word apart. A row without the separator is the index's answer; one with it is read.
+ */
+const nearStems = (scope, node, stems) => {
+    const { database, corpus, execution } = scope;
+    const stemmer = execution.stemmer;
+    const rows = database
+        .prepare(`SELECT m.id AS id, m.text AS text FROM ${corpus.rows} m WHERE m.id IN (SELECT rowid FROM ${corpus.stems} WHERE ${corpus.stems} MATCH ?) LIMIT ?`)
+        .all(`stems : ((${stems}) AND ${quoted(STEM_SEPARATOR)})`, QUERY_LIMITS.candidates + 1);
+    if (rows.length > QUERY_LIMITS.candidates)
+        exhausted("candidate rows");
+    const wanted = stemmer.stemSequences(node.value).filter((sequence) => sequence.length > 1);
+    const kept = rows.flatMap(({ id, text }) => {
+        scope.check();
+        const sequences = stemmer.stemSequences(String(text));
+        return wanted.some((query) => sequences.some((sequence) => near(sequence, query, node.slop)))
+            ? [Number(id)]
+            : [];
+    });
+    return bound(`m.id IN (SELECT rowid FROM ${corpus.stems} WHERE ${corpus.stems} MATCH ?) OR m.id IN (SELECT value FROM json_each(?))`, `stems : ((${stems}) NOT ${quoted(STEM_SEPARATOR)})`, JSON.stringify(kept));
+};
 const stemmedText = (node, scope) => {
     const { execution, corpus } = scope;
     if (!execution.stemmer && !execution.unstemmed)
         throw new Error("a stemmed leaf reached the compiler without the store's stemmer");
     const text = normalize(node.value);
-    const stems = stemsOf(scope, node.value);
+    const match = ftsMatch(node);
+    const stems = stemsOf(scope, node);
+    const byStems = stems && node.slop !== undefined
+        ? nearStems(scope, node, stems)
+        : stems
+            ? bound(`m.id IN (SELECT rowid FROM ${corpus.stems} WHERE ${corpus.stems} MATCH ?)`, `stems : (${stems})`)
+            : undefined;
     // Words OR stems: two spellings can fold one word to different stems, and every exact hit must stay.
     return always(/[\p{L}\p{N}]/u.test(text)
-        ? scope.everywhere(node, text, {
-            sql: `m.id IN (SELECT rowid FROM ${corpus.words} WHERE ${corpus.words} MATCH ?)${stems ? ` OR m.id IN (SELECT rowid FROM ${corpus.stems} WHERE ${corpus.stems} MATCH ?)` : ""}`,
-            params: [`normalized_text : (${quoted(text)})`, ...(stems ? [`stems : (${stems})`] : [])],
+        ? scope.everywhere(node, {
+            sql: `m.id IN (SELECT rowid FROM ${corpus.words} WHERE ${corpus.words} MATCH ?)${byStems ? ` OR ${byStems.sql}` : ""}`,
+            params: [`normalized_text : (${match})`, ...(byStems?.params ?? [])],
             exact: true,
-            fts: quoted(text),
+            fts: match,
             ...(stems ? { stems } : {}),
         })
         : bound("0"));
@@ -86,9 +153,9 @@ const words = (node, scope) => {
         return stemmedText(node, scope);
     if (operator === "term" || operator === "phrase") {
         const text = normalize(value);
-        const stems = stemsOf(scope, value);
+        const stems = stemsOf(scope, node);
         return always(/[\p{L}\p{N}]/u.test(text)
-            ? scope.everywhere(node, text, { ...wordMatch(corpus, quoted(text)), ...(stems ? { stems } : {}) })
+            ? scope.everywhere(node, { ...wordMatch(corpus, ftsMatch(node)), ...(stems ? { stems } : {}) })
             : bound("0"));
     }
     const pattern = operator === "wildcard" ? wildcardPattern(normalize(value)) : foldRegex(value, node.span);
@@ -181,10 +248,10 @@ const size = (node, { corpus }) => {
     const range = combine(conditions, "AND");
     return always(bound(`EXISTS (SELECT 1 FROM attachments att WHERE att.attachable_type='${corpus.item}' AND att.attachable_id=m.id AND att.size IS NOT NULL AND ${range.sql})`, ...range.params));
 };
-const attachmentText = (which) => ({ value }, scope) => {
-    const text = normalize(value);
+const attachmentText = (which) => (node, scope) => {
+    const text = normalize(node.value);
     // Never `fts`: the ranking ANDs every required word into message_words, where a file's words are not.
-    const set = scope.attachmentWords(quoted(text), which);
+    const set = scope.attachmentWords(ftsMatch(node), which);
     return always(/[\p{L}\p{N}]/u.test(text) ? bound(`m.id IN (${set.sql})`, ...set.params) : bound("0"));
 };
 const date = (node) => {

package/dist/store/sqlite/lucene.js

@@ -4,7 +4,7 @@ import { isStemmed } from "../../search/lucene/resolved.js";
 import { exhausted, QUERY_LIMITS, searchError } from "../../search/lucene/types.js";
 import { normalize } from "../normalize.js";
 import { emailHitsByPk } from "./emails.js";
-import { combine, FIELD_COMPILERS, quoted, SPEECH, } from "./lucene-fields.js";
+import { combine, FIELD_COMPILERS, ftsMatch, SPEECH, } from "./lucene-fields.js";
 import { hitsByPk } from "./search.js";
 import { read } from "./transaction.js";
 export { prefixOf } from "./lucene-fields.js";
@@ -83,11 +83,12 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
         params: [match],
     });
     /** A bare word also matches a transcript, a file's text and a word of a file's name. */
-    const everywhere = (node, text, fragment) => {
+    const everywhere = (node, fragment) => {
         if (!node.implicit || fragment.sql === "0")
             return fragment;
-        const files = attachmentWords(quoted(text), "any");
-        const elsewhere = { sql: `${files.sql} UNION ${namedSql}`, params: [...files.params, quoted(text)] };
+        const match = ftsMatch(node);
+        const files = attachmentWords(match, "any");
+        const elsewhere = { sql: `${files.sql} UNION ${namedSql}`, params: [...files.params, match] };
         return {
             ...fragment,
             sql: `(${fragment.sql} OR m.id IN (${elsewhere.sql}))`,
@@ -285,10 +286,10 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
     }
     // Among hits the message text does not hold: a transcript, then a file's name, then a file's text. bm25 scores
     // of different indexes do not compare, and a long spreadsheet must not crowd out what was said.
-    const places = [...fragments.values()].flatMap(({ node, fragment }) => fragment.elsewhere && fragment.fts ? [normalize(node.value)] : []);
+    const places = [...fragments.values()].flatMap(({ node, fragment }) => fragment.elsewhere && fragment.fts ? [ftsMatch(node)] : []);
     if (places.length && !execution.newest) {
         ranked.sql.push(`s(id, tier) AS MATERIALIZED (SELECT att.attachable_id, min(CASE WHEN ${SPEECH} THEN 1 ELSE 3 END) FROM attachments att WHERE att.attachable_type='${corpus.item}' AND att.id IN (SELECT rowid FROM attachment_words WHERE attachment_words MATCH ?) GROUP BY att.attachable_id UNION ALL SELECT attachable_id, 2 FROM (${namedSql}))`);
-        ranked.params.push(places.map((text) => quoted(text)).join(" OR "), places.map((text) => quoted(text)).join(" OR "));
+        ranked.params.push(places.join(" OR "), places.join(" OR "));
     }
     const placeTier = places.length && !execution.newest ? "coalesce((SELECT min(tier) FROM s WHERE s.id=m.id), 4)," : "";
     if (exactTier) {
@@ -342,10 +343,10 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
         if (!placeLeaves.length || !pks.length || found.length !== pks.length)
             return found;
         const keys = JSON.stringify(pks);
-        const texts = placeLeaves.map(({ node }) => normalize(node.value)).filter((text) => /[\p{L}\p{N}]/u.test(text));
-        if (!texts.length)
+        const wordy = placeLeaves.filter(({ node }) => /[\p{L}\p{N}]/u.test(normalize(node.value)));
+        if (!wordy.length)
             return found;
-        const match = texts.map((text) => quoted(text)).join(" OR ");
+        const match = wordy.map(({ node }) => ftsMatch(node)).join(" OR ");
         const implicit = placeLeaves.some(({ node }) => node.implicit);
         const inText = new Set(implicit
             ? database
@@ -369,7 +370,6 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
                 .prepare(`SELECT att.attachable_id AS id, att.name AS name FROM attachments att WHERE att.attachable_type='${corpus.item}' AND att.attachable_id IN (SELECT value FROM json_each(?)) AND att.name IS NOT NULL ORDER BY att.position`)
                 .all(keys)
             : [];
-        const wanted = texts.map((text) => text.split(/[^\p{L}\p{N}]+/u).filter(Boolean));
         return found.map((hit, index) => {
             const pk = pks[index];
             const transcript = files.find((row) => Number(row.id) === pk && Number(row.speech) === 1);
@@ -378,7 +378,12 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
                 if (Number(row.id) !== pk)
                     return false;
                 const words = normalize(String(row.name)).split(/[^\p{L}\p{N}]+/u);
-                return wanted.some((phrase) => words.some((_, at) => phrase.every((word, offset) => words[at + offset] === word)));
+                return wordy.some(({ node }) => {
+                    const phrase = normalize(node.value).match(/[\p{L}\p{N}]+/gu) ?? [];
+                    if (node.slop !== undefined)
+                        return phrase.every((word) => words.includes(word));
+                    return words.some((_, at) => phrase.every((word, offset) => words[at + offset] === word));
+                });
             });
             const place = inText.has(pk)
                 ? ["text", hit.text]

package/dist/store/sqlite/meeting-chat-lines.d.ts

@@ -0,0 +1,3 @@
+import { type MeetingChatLinesStore } from "../../meetings/index.js";
+import type { StoreContext } from "./open.js";
+export declare const meetingChatLinesOver: ({ database }: StoreContext) => MeetingChatLinesStore;

package/dist/store/sqlite/meeting-chat-lines.js

@@ -0,0 +1,34 @@
+import { CliError } from "@wirecat/cli-base";
+import { CHAT_MESSAGES_READ } from "../../meetings/index.js";
+import { checkMeetingCancelled } from "./meeting-operation.js";
+import { positiveReadInteger } from "./meeting-reads.js";
+import { meetingSelectionSql } from "./meeting-selection.js";
+import { read } from "./transaction.js";
+export const meetingChatLinesOver = ({ database }) => ({
+    async meetingChatLines(input) {
+        checkMeetingCancelled(input.signal);
+        positiveReadInteger(input.accountId, "accountId");
+        const most = input.maxMessages ?? CHAT_MESSAGES_READ;
+        if (!Number.isSafeInteger(most) || most < 1 || most > CHAT_MESSAGES_READ)
+            throw new CliError("validation_error", `read 1 through ${CHAT_MESSAGES_READ} chat messages`);
+        return read(database, () => {
+            const { clauses, params } = meetingSelectionSql(input);
+            const rows = database
+                .prepare(`SELECT c.meeting_id, m.account_id, m.title, c.sent_at, coalesce(c.sender_name, p.display_name) AS sender, c.text
+           FROM meetings m JOIN meeting_chat_messages c ON c.meeting_id = m.id
+           LEFT JOIN meeting_participants p ON p.id = c.sender_participant_id
+           WHERE ${clauses.join(" AND ")} ORDER BY c.sent_at, c.id LIMIT ?`)
+                .all(...params, most + 1);
+            if (rows.length > most)
+                throw new CliError("validation_error", `the selection has more than ${most} chat messages; narrow it`);
+            return rows.map((row) => ({
+                meetingId: Number(row.meeting_id),
+                accountId: Number(row.account_id),
+                title: row.title === null ? null : String(row.title),
+                sentAt: Number(row.sent_at),
+                sender: row.sender === null ? null : String(row.sender),
+                text: String(row.text),
+            }));
+        });
+    },
+});

package/dist/store/sqlite/meeting-review.d.ts

@@ -0,0 +1,4 @@
+import { type MeetingReviewStore } from "../../meetings/index.js";
+import type { StoreContext } from "./open.js";
+/** Talk and words come from one transcript per meeting, its earliest current one, as in meeting stats. */
+export declare const meetingReviewOver: ({ database }: StoreContext) => MeetingReviewStore;

package/dist/store/sqlite/meeting-review.js

@@ -0,0 +1,97 @@
+import { CliError } from "@wirecat/cli-base";
+import { REVIEW_LIMIT } from "../../meetings/index.js";
+import { fromJson } from "./events.js";
+import { checkMeetingCancelled } from "./meeting-operation.js";
+import { positiveReadInteger } from "./meeting-reads.js";
+import { meetingSelectionSql } from "./meeting-selection.js";
+import { read } from "./transaction.js";
+const number = (value) => (value === null || value === undefined ? null : Number(value));
+const text = (value) => (value === null || value === undefined ? null : String(value));
+/** Talk and words come from one transcript per meeting, its earliest current one, as in meeting stats. */
+export const meetingReviewOver = ({ database }) => ({
+    async meetingReview(input) {
+        checkMeetingCancelled(input.signal);
+        positiveReadInteger(input.accountId, "accountId");
+        const limit = input.limit ?? REVIEW_LIMIT.default;
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > REVIEW_LIMIT.most)
+            throw new CliError("validation_error", `a review shows 1 through ${REVIEW_LIMIT.most} meetings`);
+        return read(database, () => {
+            const { clauses, params } = meetingSelectionSql(input);
+            const meetings = database
+                .prepare(`SELECT m.id, m.account_id, m.title, m.started_at, m.duration_ms, m.participants_count FROM meetings m
+           WHERE ${clauses.join(" AND ")} ORDER BY m.started_at DESC, m.id DESC LIMIT ?`)
+                .all(...params, limit + 1);
+            const shown = meetings.slice(0, limit);
+            const items = new Map();
+            for (const row of shown)
+                items.set(Number(row.id), {
+                    meetingId: Number(row.id),
+                    accountId: Number(row.account_id),
+                    title: text(row.title),
+                    startedAt: number(row.started_at),
+                    durationMs: number(row.duration_ms),
+                    participantsCount: number(row.participants_count),
+                    projects: [],
+                    transcript: null,
+                    speakers: [],
+                    summary: null,
+                });
+            if (items.size) {
+                const ids = [...items.keys()];
+                const marks = ids.map(() => "?").join(",");
+                checkMeetingCancelled(input.signal);
+                const talk = database
+                    .prepare(`WITH chosen AS (SELECT min(t.id) AS id, t.meeting_id FROM meeting_transcripts t
+               WHERE t.meeting_id IN (${marks}) AND t.deleted_at IS NULL AND t.superseded_at IS NULL GROUP BY t.meeting_id)
+             SELECT c.meeting_id, coalesce(person.name, i.name, r.speaker_name, p.display_name) AS speaker,
+               count(*) AS lines, sum(max(r.end_ms - r.start_ms, 0)) AS talk_ms,
+               sum(length(trim(r.text)) - length(replace(trim(r.text), ' ', '')) + (length(trim(r.text)) > 0)) AS words
+             FROM chosen c JOIN meeting_transcript_rows r ON r.meeting_transcript_id = c.id
+             LEFT JOIN meeting_participants p ON p.id = r.speaker_participant_id
+             LEFT JOIN identities i ON i.id = p.identity_id
+             LEFT JOIN identity_links l ON l.identity_id = p.identity_id
+             LEFT JOIN persons person ON person.id = l.person_id
+             GROUP BY c.meeting_id, speaker ORDER BY c.meeting_id, talk_ms DESC`)
+                    .all(...ids);
+                for (const row of talk) {
+                    const item = items.get(Number(row.meeting_id));
+                    item.transcript ??= { lines: 0, words: 0 };
+                    item.transcript.lines += Number(row.lines);
+                    item.transcript.words += Number(row.words);
+                    if (item.speakers.length < 3)
+                        item.speakers.push({ name: text(row.speaker), talkMs: Number(row.talk_ms) });
+                }
+                const transcribed = database
+                    .prepare(`SELECT DISTINCT meeting_id FROM meeting_transcripts
+             WHERE meeting_id IN (${marks}) AND deleted_at IS NULL AND superseded_at IS NULL`)
+                    .all(...ids);
+                for (const row of transcribed) {
+                    const item = items.get(Number(row.meeting_id));
+                    item.transcript ??= { lines: 0, words: 0 };
+                }
+                const summaries = database
+                    .prepare(`SELECT meeting_id, source, title, overview, next_steps, doc_url FROM meeting_summaries
+             WHERE meeting_id IN (${marks}) ORDER BY coalesce(external_updated_at, updated_at) DESC, id DESC`)
+                    .all(...ids);
+                for (const row of summaries) {
+                    const item = items.get(Number(row.meeting_id));
+                    item.summary ??= {
+                        source: String(row.source),
+                        title: text(row.title),
+                        overview: text(row.overview),
+                        nextSteps: fromJson(row.next_steps) ?? [],
+                        url: text(row.doc_url),
+                    };
+                }
+                const projects = database
+                    .prepare(`SELECT l.from_id, p.name FROM links l JOIN projects p ON p.id = l.to_id
+             WHERE l.from_type = 'meeting' AND l.from_id IN (${marks}) AND l.to_type = 'project' AND l.kind = 'member-of'
+               AND l.anchor IS NULL AND l.confirmed = 1 AND p.account_id IS NULL AND p.deleted_at IS NULL ORDER BY p.name`)
+                    .all(...ids);
+                for (const row of projects)
+                    items.get(Number(row.from_id)).projects.push(String(row.name));
+            }
+            return { items: [...items.values()], hasMore: meetings.length > limit };
+        });
+    },
+});

package/dist/store/sqlite/meetings.d.ts

@@ -1,4 +1,4 @@
-import type { Attachment, MeetingContextStore, MeetingParticipantSearchStore, MeetingPreparationContextStore, MeetingPreparationKnowledgeStore, MeetingPreparationNotesStore, MeetingRelatedHistoryStore, MeetingSearchIndexStore, MeetingSearchStore, MeetingSeriesHistoryStore, MeetingStatsStore, MeetingStore, MeetingTranscriptReceiptStore, MeetingTranscriptStore, NewRecord } from "../../meetings/index.js";
+import type { Attachment, MeetingChatLinesStore, MeetingContextStore, MeetingParticipantSearchStore, MeetingPreparationContextStore, MeetingPreparationKnowledgeStore, MeetingPreparationNotesStore, MeetingRelatedHistoryStore, MeetingReviewStore, MeetingSearchIndexStore, MeetingSearchStore, MeetingSeriesHistoryStore, MeetingStatsStore, MeetingStore, MeetingTranscriptReceiptStore, MeetingTranscriptStore, NewRecord } from "../../meetings/index.js";
 import type { CacheDatabase } from "../driver.js";
 import { type MeetingContextReadCapabilities, type MeetingReadCapabilities } from "./meeting-reads.js";
 import type { StoreContext } from "./open.js";
@@ -11,7 +11,7 @@ export declare const saveAttachment: (database: CacheDatabase, type: string, par
 export declare const drainMeetingIndex: (database: CacheDatabase, batch?: number) => number;
 /** Each word of the query, as a prefix, all required. */
 export declare const wordsQuery: (query: string) => string | null;
-export type StoredMeetings = MeetingStore & MeetingPreparationContextStore & MeetingPreparationKnowledgeStore & MeetingPreparationNotesStore & MeetingRelatedHistoryStore & MeetingSeriesHistoryStore & MeetingTranscriptStore & MeetingReadCapabilities & MeetingContextReadCapabilities & MeetingParticipantSearchStore & MeetingSearchStore & MeetingTranscriptReceiptStore & MeetingContextStore & MeetingSearchIndexStore & MeetingStatsStore;
+export type StoredMeetings = MeetingStore & MeetingPreparationContextStore & MeetingPreparationKnowledgeStore & MeetingPreparationNotesStore & MeetingRelatedHistoryStore & MeetingSeriesHistoryStore & MeetingTranscriptStore & MeetingReadCapabilities & MeetingContextReadCapabilities & MeetingParticipantSearchStore & MeetingSearchStore & MeetingTranscriptReceiptStore & MeetingContextStore & MeetingSearchIndexStore & MeetingStatsStore & MeetingReviewStore & MeetingChatLinesStore;
 /** The `MeetingStore` of `src/meetings/` over the shared store. */
 export declare const meetingStoreOver: (context: StoreContext) => StoredMeetings;
 export {};