@wirecat/cli-core 0.379.0 → 0.380.0

package/dist/store/sqlite/meeting-hit-query.js

@@ -0,0 +1,262 @@
+import { CliError, singleLine } from "@wirecat/cli-base";
+import { isNumberWord, widenWords } from "../../search/garbled.js";
+import { knownRussianWord } from "../../search/russian-dictionary.js";
+import { fold, normalize } from "../normalize.js";
+import { meetingStemmableText } from "./meeting-stem-state.js";
+const WORD = /[\p{L}\p{N}\p{M}]+/gu;
+const MOST_WORDS = 128;
+const quote = (word) => `"${word.replaceAll('"', '""')}"`;
+/** The candidates `from:` picks among: a linked person with all their identities, else one identity or name. */
+const speakers = (database, accountId) => {
+    const found = new Map();
+    const add = (key, label, names, participant, raw) => {
+        const speaker = found.get(key) ?? { label, names: new Set(), participants: new Set(), raw: new Set() };
+        for (const name of names)
+            if (name?.trim())
+                speaker.names.add(fold(name.trim()));
+        if (participant !== null)
+            speaker.participants.add(participant);
+        if (raw)
+            speaker.raw.add(raw);
+        found.set(key, speaker);
+    };
+    const participants = database
+        .prepare(`SELECT p.id,p.identity_id,p.display_name,i.name AS identity_name,l.person_id,person.name AS person_name
+       FROM meeting_participants p JOIN meetings m ON m.id=p.meeting_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 WHERE m.account_id=? AND m.deleted_at IS NULL`)
+        .all(accountId);
+    const personNames = database.prepare("SELECT i.name FROM identity_links l JOIN identities i ON i.id=l.identity_id WHERE l.person_id=?");
+    for (const row of participants) {
+        const names = [row.display_name, row.identity_name, row.person_name].map((name) => name === null || name === undefined ? null : String(name));
+        const label = names.find((name) => name?.trim()) ?? "unnamed";
+        if (row.person_id !== null && row.person_id !== undefined) {
+            const others = personNames.all(Number(row.person_id)).map((one) => (one.name === null ? null : String(one.name)));
+            add(`person:${row.person_id}`, String(row.person_name ?? label), [...names, ...others], Number(row.id));
+        }
+        else if (row.identity_id !== null && row.identity_id !== undefined)
+            add(`identity:${row.identity_id}`, label, names, Number(row.id));
+        else
+            add(`name:${fold(label)}`, label, names, Number(row.id));
+    }
+    const unlinked = database
+        .prepare(`SELECT DISTINCT r.speaker_name AS name FROM meeting_transcript_rows r
+       JOIN meeting_transcripts t ON t.id=r.meeting_transcript_id JOIN meetings m ON m.id=t.meeting_id
+       WHERE m.account_id=? AND m.deleted_at IS NULL AND r.speaker_participant_id IS NULL AND r.speaker_name IS NOT NULL
+       UNION SELECT DISTINCT c.sender_name FROM meeting_chat_messages c JOIN meetings m ON m.id=c.meeting_id
+       WHERE m.account_id=? AND m.deleted_at IS NULL AND c.sender_participant_id IS NULL AND c.sender_name IS NOT NULL`)
+        .all(accountId, accountId);
+    for (const row of unlinked) {
+        const name = String(row.name);
+        if (!name.trim())
+            continue;
+        const same = [...found.values()].find((speaker) => speaker.names.has(fold(name.trim())));
+        if (same)
+            same.raw.add(name);
+        else
+            add(`name:${fold(name.trim())}`, name, [name], null, name);
+    }
+    return [...found.values()];
+};
+/**
+ * As `pickPerson` for messages: a name matched as a fragment, the exact name first, and an ambiguous one is an
+ * error with the candidates rather than a guess.
+ */
+const pickSpeaker = (database, accountId, reference) => {
+    const wanted = fold(reference.trim());
+    const everyone = speakers(database, accountId).sort((a, b) => a.label.localeCompare(b.label));
+    const exact = everyone.filter((speaker) => speaker.names.has(wanted));
+    const matches = exact.length
+        ? exact
+        : everyone.filter((speaker) => [...speaker.names].some((n) => n.includes(wanted)));
+    const [one] = matches;
+    if (matches.length === 1 && one)
+        return { kind: "speaker", participants: [...one.participants].sort((a, b) => a - b), names: [...one.raw].sort() };
+    if (matches.length === 0)
+        throw new CliError("not_found", `from:${reference} — nobody spoke as "${reference}"`);
+    throw new CliError("validation_error", `from:${reference} matches ${matches.length} speakers — write more of the name:\n${matches
+        .map((speaker) => `  ${singleLine(speaker.label)}`)
+        .join("\n")}`, { candidates: matches.map((speaker) => ({ name: speaker.label })) });
+};
+/** The parsed query, its names resolved and its words stemmed and widened, before any text is read. */
+export const resolveMeetingQuery = (database, accountId, ast, state) => {
+    const all = [];
+    const wordsOf = (value, exact) => {
+        const words = (value.match(WORD) ?? [])
+            .filter((raw) => normalize(raw))
+            .map((raw) => {
+            const literal = normalize(raw);
+            return {
+                raw,
+                literal,
+                whole: exact || isNumberWord(literal),
+                stems: state.stemmer && raw.length <= 1024 && !exact
+                    ? [...new Set(state.stemmer.explain(raw).map((word) => word.stem))]
+                    : [],
+                widened: [],
+            };
+        });
+        for (const term of words)
+            all.push(term);
+        if (all.length > MOST_WORDS)
+            throw new CliError("validation_error", "Meeting search supports at most 128 query words");
+        return words;
+    };
+    const resolve = (node) => {
+        if (node.kind === "boolean")
+            return {
+                kind: "boolean",
+                must: node.clauses.filter((c) => c.occur === "must").map((c) => resolve(c.node)),
+                should: node.clauses.filter((c) => c.occur === "should").map((c) => resolve(c.node)),
+                not: node.clauses.filter((c) => c.occur === "must_not").map((c) => resolve(c.node)),
+            };
+        if (node.field === "from")
+            return pickSpeaker(database, accountId, node.value);
+        const exact = node.field === "exact";
+        const words = wordsOf(node.value, exact);
+        if (node.operator === "phrase" && node.slop !== undefined && words.length > 1)
+            return { kind: "near", exact, words, lines: node.slop };
+        return { kind: node.operator === "phrase" && words.length > 1 ? "phrase" : "words", exact, words };
+    };
+    const tree = resolve(ast.root);
+    const stemmer = state.stemmer;
+    const widening = [];
+    const collect = (node) => {
+        if (node.kind === "boolean")
+            [...node.must, ...node.should, ...node.not].forEach(collect);
+        else if ((node.kind === "words" || node.kind === "near") && !node.exact)
+            for (const term of node.words)
+                widening.push(term);
+    };
+    collect(tree);
+    if (stemmer && state.through > 0 && widening.length) {
+        const widened = widenWords(widening, database
+            .prepare("SELECT term,doc FROM meeting_words_vocab WHERE col='normalized_text'")
+            .all()
+            .map((row) => ({ term: String(row.term), docs: Number(row.doc) })), (word) => [...new Set(stemmer.explain(word).map((part) => part.stem))], knownRussianWord);
+        widening.forEach((word, at) => {
+            word.widened = widened[at] ?? [];
+        });
+    }
+    return tree;
+};
+/**
+ * A `(rid, tier)` select: tier 0 the typed form, 1 another form the stems found, 2 a garbled spelling. A passage
+ * all of a query's required parts reach takes the worst tier among them; one any optional part reaches, the best.
+ */
+export const meetingQuerySql = (tree, state) => {
+    const params = [];
+    const stems = state.stemmer !== null && state.through > 0;
+    const word = (term) => {
+        params.push(`normalized_text : (${quote(term.literal)}${term.whole ? "" : "*"})`);
+        let select = "SELECT rowid AS rid,0 AS tier FROM meeting_words WHERE meeting_words MATCH ?";
+        if (stems && term.stems.length) {
+            params.push(`stems : (${term.stems.map(quote).join(" OR ")})`, state.through);
+            select += " UNION SELECT rowid,1 FROM meeting_stems WHERE meeting_stems MATCH ? AND rowid<=?";
+        }
+        if (term.widened.length) {
+            params.push(`normalized_text : (${term.widened.map(quote).join(" OR ")})`);
+            select += " UNION SELECT rowid,2 FROM meeting_words WHERE meeting_words MATCH ?";
+        }
+        return `SELECT rid,min(tier) AS tier FROM (${select}) GROUP BY rid`;
+    };
+    const all = (parts) => parts.length === 1
+        ? parts[0]
+        : `SELECT rid,max(tier) AS tier FROM (${parts.join(" UNION ALL ")}) GROUP BY rid HAVING count(*)=${parts.length}`;
+    const any = (parts) => parts.length === 1
+        ? parts[0]
+        : `SELECT rid,min(tier) AS tier FROM (${parts.join(" UNION ALL ")}) GROUP BY rid`;
+    const nothing = "SELECT NULL AS rid,0 AS tier WHERE 0";
+    const compile = (node) => {
+        if (node.kind === "words")
+            return node.words.length ? all(node.words.map(word)) : nothing;
+        if (node.kind === "near") {
+            const lines = node.words.map((term, i) => `w${i} AS MATERIALIZED (SELECT r.meeting_transcript_id AS t,r.position AS p,r.id,h.tier FROM (${word(term)}) h JOIN meeting_transcript_rows r ON h.rid%4=1 AND r.id=h.rid/4)`);
+            const nearest = node.words.map((_, i) => `(SELECT min(x.tier) FROM w${i} x WHERE x.t=c.t AND x.p BETWEEN c.p-${node.lines} AND c.p+${node.lines})`);
+            return `SELECT rid,tier FROM (WITH ${lines.join(",")}, c AS (${node.words
+                .map((_, i) => `SELECT t,p,id FROM w${i}`)
+                .join(" UNION ")}) SELECT c.id*4+1 AS rid,max(${nearest.join(",")}) AS tier FROM c) WHERE tier IS NOT NULL`;
+        }
+        if (node.kind === "phrase") {
+            params.push(`normalized_text : ${quote(node.words.map((term) => term.literal).join(" "))}`);
+            let select = "SELECT rowid AS rid,0 AS tier FROM meeting_words WHERE meeting_words MATCH ?";
+            const phrases = node.exact ? undefined : state.stemmer?.phrases(node.words.map((term) => term.raw).join(" "));
+            if (stems && phrases) {
+                params.push(`stems : (${phrases})`, state.through);
+                select += " UNION SELECT rowid,1 FROM meeting_stems WHERE meeting_stems MATCH ? AND rowid<=?";
+            }
+            return `SELECT rid,min(tier) AS tier FROM (${select}) GROUP BY rid`;
+        }
+        if (node.kind === "speaker") {
+            params.push(JSON.stringify(node.participants), JSON.stringify(node.names));
+            params.push(JSON.stringify(node.participants), JSON.stringify(node.names));
+            return `SELECT r.id*4+1 AS rid,0 AS tier FROM meeting_transcript_rows r
+        WHERE r.speaker_participant_id IN (SELECT value FROM json_each(?)) OR (r.speaker_participant_id IS NULL AND r.speaker_name IN (SELECT value FROM json_each(?)))
+        UNION ALL SELECT c.id*4+2,0 FROM meeting_chat_messages c
+        WHERE c.sender_participant_id IN (SELECT value FROM json_each(?)) OR (c.sender_participant_id IS NULL AND c.sender_name IN (SELECT value FROM json_each(?)))`;
+        }
+        // Lucene: optional clauses only count when nothing is required; a part that is only exclusions matches nothing.
+        const positive = node.must.length
+            ? all(node.must.map(compile))
+            : node.should.length
+                ? any(node.should.map(compile))
+                : nothing;
+        if (!node.not.length)
+            return positive;
+        return `SELECT rid,tier FROM (${positive}) WHERE rid NOT IN (${node.not.map((part) => `SELECT rid FROM (${compile(part)})`).join(" UNION ")})`;
+    };
+    return { sql: compile(tree), params };
+};
+/**
+ * The tree checked again against a passage's current text — an index lags an edit — and the garbled spellings
+ * that let it match. A speaker cannot be read from the text, so it passes here.
+ */
+export const matchMeetingText = (tree, text, stemmer) => {
+    const tokens = normalize(text).match(/[\p{L}\p{N}]+/gu) ?? [];
+    let stemTokens;
+    const stemsOf = () => (stemTokens ??= stemmer
+        ? new Set(stemmer.explain(meetingStemmableText(text)).map((word) => word.stem))
+        : new Set());
+    const word = (term) => {
+        if (term.whole ? tokens.includes(term.literal) : tokens.some((token) => token.startsWith(term.literal)))
+            return [];
+        if (term.stems.some((stem) => stemsOf().has(stem)))
+            return [];
+        const to = term.widened.filter((widened) => tokens.includes(widened));
+        return to.length ? [{ from: term.raw, to }] : null;
+    };
+    const check = (node) => {
+        if (node.kind === "speaker")
+            return [];
+        // The other words are on neighbouring lines, so only this line's garbled spellings are named.
+        if (node.kind === "near")
+            return node.words.flatMap((term) => word(term) ?? []);
+        if (node.kind === "words" || node.kind === "phrase") {
+            const found = [];
+            for (const term of node.words) {
+                const one = word(term);
+                if (!one)
+                    return null;
+                for (const fix of one)
+                    found.push(fix);
+            }
+            return found;
+        }
+        if (node.not.some((part) => check(part) !== null))
+            return null;
+        if (node.must.length) {
+            const found = [];
+            for (const part of node.must) {
+                const one = check(part);
+                if (!one)
+                    return null;
+                for (const fix of one)
+                    found.push(fix);
+            }
+            return found;
+        }
+        const matched = node.should.map(check).filter((one) => one !== null);
+        return matched.length ? matched.flat() : null;
+    };
+    return check(tree);
+};

package/dist/store/sqlite/meeting-hit-search.js

@@ -1,11 +1,11 @@
 import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
-import { formatMeetingReference } from "../../meetings/index.js";
-import { normalize } from "../normalize.js";
+import { formatMeetingReference, parseMeetingQuery } from "../../meetings/index.js";
+import { matchMeetingText, meetingQuerySql, resolveMeetingQuery } from "./meeting-hit-query.js";
 import { indexedText } from "./meeting-index-values.js";
 import { checkMeetingCancelled } from "./meeting-operation.js";
 import { positiveReadInteger } from "./meeting-reads.js";
-import { meetingStemmableText, meetingStemState } from "./meeting-stem-state.js";
+import { meetingStemState } from "./meeting-stem-state.js";
 import { read } from "./transaction.js";
 const fail = (message) => {
     throw new CliError("validation_error", message);
@@ -42,8 +42,9 @@ const cursorOf = (value, key) => {
     catch {
         return fail("Invalid meeting search cursor");
     }
-    if (parsed?.version !== 1 ||
+    if (parsed?.version !== 2 ||
         parsed.key !== key ||
+        ![0, 1, 2].includes(parsed.tier) ||
         !Number.isSafeInteger(parsed.started) ||
         Math.abs(parsed.started) > 8640000000000000 ||
         !Number.isSafeInteger(parsed.meeting) ||
@@ -86,21 +87,14 @@ export function meetingHitSearchOver({ database }) {
                 fail("Meeting search limit must be from 1 through 1000");
             if (!Number.isSafeInteger(maxReadBytes) || maxReadBytes < 1 || maxReadBytes > 64 * 1024 ** 2)
                 fail("Meeting search byte limit must be from 1 through 67108864");
-            if (typeof rawQuery !== "string" || Buffer.byteLength(rawQuery) > 65536)
+            if (typeof rawQuery === "string" && Buffer.byteLength(rawQuery) > 65536)
                 fail("Meeting search query must be a bounded string");
-            const rawWords = rawQuery.match(/[\p{L}\p{N}\p{M}]+/gu)?.filter((word) => normalize(word)) ?? [];
-            if (rawWords.length > 128)
-                fail("Meeting search supports at most 128 query words");
+            const ast = typeof rawQuery === "string" ? parseMeetingQuery(rawQuery) : rawQuery;
             return read(database, () => {
                 checkMeetingCancelled(input.signal);
                 const state = meetingStemState(database, input.accountId);
-                const terms = rawWords.map((raw) => ({
-                    literal: normalize(raw),
-                    stems: state.stemmer && raw.length <= 1024
-                        ? [...new Set(state.stemmer.explain(raw).map((word) => word.stem))]
-                        : [],
-                }));
-                const key = fingerprint(JSON.stringify(terms), input, state.identity);
+                const tree = resolveMeetingQuery(database, input.accountId, ast, state);
+                const key = fingerprint(JSON.stringify(tree), input, state.identity);
                 const after = cursorOf(input.after, key);
                 const pending = database
                     .prepare(`SELECT 1 FROM meeting_index_pending p
@@ -118,20 +112,8 @@ export function meetingHitSearchOver({ database }) {
                     indexing: pending || !state.stemmer || state.through < state.watermark ? "pending" : "ready",
                     indexCompleteness: "unknown",
                 };
-                if (terms.length === 0)
-                    return { items: [], hasMore: false, nextCursor: null, coverage };
                 const clauses = ["m.account_id=?", "m.deleted_at IS NULL"];
-                const queryParams = [];
-                const termTables = terms.map((term, i) => {
-                    queryParams.push(`normalized_text : ("${term.literal}"*)`);
-                    let select = "SELECT rowid AS rid FROM meeting_words WHERE meeting_words MATCH ?";
-                    if (state.stemmer && state.through > 0 && term.stems.length) {
-                        queryParams.push(`stems : (${term.stems.map((stem) => `"${stem.replaceAll('"', '""')}"`).join(" OR ")})`, state.through);
-                        select += " UNION SELECT rowid AS rid FROM meeting_stems WHERE meeting_stems MATCH ? AND rowid<=?";
-                    }
-                    return `term_${i} AS (${select})`;
-                });
-                const matching = terms.map((_, i) => `SELECT rid FROM term_${i}`).join(" INTERSECT ");
+                const { sql: matching, params: queryParams } = meetingQuerySql(tree, state);
                 const params = [input.accountId];
                 if (input.meetingId !== undefined) {
                     clauses.push("m.id=?");
@@ -170,17 +152,17 @@ export function meetingHitSearchOver({ database }) {
                     params.push(input.tagId);
                 }
                 const seek = after
-                    ? "WHERE h.started<? OR (h.started=? AND (h.meeting_id>? OR (h.meeting_id=? AND (h.kind>? OR (h.kind=? AND h.id>?)))))"
+                    ? "WHERE h.tier>? OR (h.tier=? AND (h.started<? OR (h.started=? AND (h.meeting_id>? OR (h.meeting_id=? AND (h.kind>? OR (h.kind=? AND h.id>?)))))))"
                     : "";
                 if (after)
-                    params.push(after.started, after.started, after.meeting, after.meeting, after.kind, after.kind, after.id);
-                const sql = `WITH ${termTables.join(",")}, matches AS (${matching}), matching AS (SELECT rid FROM matches h WHERE NOT EXISTS(SELECT 1 FROM meeting_index_pending p WHERE p.id=h.rid/4 AND p.indexable_type=CASE h.rid%4 WHEN 1 THEN 'meeting_transcript_row' WHEN 2 THEN 'meeting_chat_message' ELSE 'meeting_summary' END)), selected AS (SELECT m.id,coalesce(m.started_at,0) AS started FROM meetings m WHERE ${clauses.join(" AND ")}), hits AS (
-        SELECT m.started,m.id AS meeting_id,0 AS kind,r.id,r.start_ms,${bytes("r", ["text"])} AS bytes,t.id AS transcript_id,r.position FROM matching h JOIN meeting_transcript_rows r ON h.rid%4=1 AND r.id=h.rid/4 JOIN meeting_transcripts t ON t.id=r.meeting_transcript_id AND t.superseded_at IS NULL AND t.deleted_at IS NULL JOIN selected m ON m.id=t.meeting_id
-        UNION ALL SELECT m.started,m.id,1,c.id,NULL,${bytes("c", ["text"])},NULL,NULL FROM matching h JOIN meeting_chat_messages c ON h.rid%4=2 AND c.id=h.rid/4 JOIN selected m ON m.id=c.meeting_id
-        UNION ALL SELECT m.started,m.id,2,s.id,NULL,${bytes("s", fields)},NULL,NULL FROM matching h JOIN meeting_summaries s ON h.rid%4=3 AND s.id=h.rid/4 JOIN selected m ON m.id=s.meeting_id)
+                    params.push(after.tier, after.tier, after.started, after.started, after.meeting, after.meeting, after.kind, after.kind, after.id);
+                const sql = `WITH matches AS (${matching}), matching AS (SELECT rid,tier FROM matches h WHERE NOT EXISTS(SELECT 1 FROM meeting_index_pending p WHERE p.id=h.rid/4 AND p.indexable_type=CASE h.rid%4 WHEN 1 THEN 'meeting_transcript_row' WHEN 2 THEN 'meeting_chat_message' ELSE 'meeting_summary' END)), selected AS (SELECT m.id,coalesce(m.started_at,0) AS started FROM meetings m WHERE ${clauses.join(" AND ")}), hits AS (
+        SELECT h.tier,m.started,m.id AS meeting_id,0 AS kind,r.id,r.start_ms,${bytes("r", ["text"])} AS bytes,t.id AS transcript_id,r.position FROM matching h JOIN meeting_transcript_rows r ON h.rid%4=1 AND r.id=h.rid/4 JOIN meeting_transcripts t ON t.id=r.meeting_transcript_id AND t.superseded_at IS NULL AND t.deleted_at IS NULL JOIN selected m ON m.id=t.meeting_id
+        UNION ALL SELECT h.tier,m.started,m.id,1,c.id,NULL,${bytes("c", ["text"])},NULL,NULL FROM matching h JOIN meeting_chat_messages c ON h.rid%4=2 AND c.id=h.rid/4 JOIN selected m ON m.id=c.meeting_id
+        UNION ALL SELECT h.tier,m.started,m.id,2,s.id,NULL,${bytes("s", fields)},NULL,NULL FROM matching h JOIN meeting_summaries s ON h.rid%4=3 AND s.id=h.rid/4 JOIN selected m ON m.id=s.meeting_id)
         SELECT h.*,${bytes("m", ["title"])}+${bytes("s", ["doc_url"])} AS context_bytes FROM hits h
         JOIN meetings m ON m.id=h.meeting_id LEFT JOIN meeting_summaries s ON h.kind=2 AND s.id=h.id
-        ${seek} ORDER BY h.started DESC,h.meeting_id,h.kind,h.id LIMIT ?`;
+        ${seek} ORDER BY h.tier,h.started DESC,h.meeting_id,h.kind,h.id LIMIT ?`;
                 const rows = database.prepare(sql).all(...queryParams, ...params, limit + 1);
                 let total = 0;
                 const meetingMetadata = database.prepare("SELECT title,started_at FROM meetings WHERE id=? AND account_id=? AND deleted_at IS NULL");
@@ -232,15 +214,15 @@ export function meetingHitSearchOver({ database }) {
                         startMs: row.start_ms === null ? null : Number(row.start_ms),
                     };
                 });
-                const fresh = items.filter((item) => {
-                    const literalTokens = normalize(item.text).match(/[\p{L}\p{N}]+/gu) ?? [];
-                    const missing = terms.filter((term) => !literalTokens.some((token) => token.startsWith(term.literal)));
-                    if (missing.length === 0)
-                        return true;
-                    const stemTokens = state.stemmer
-                        ? new Set(state.stemmer.explain(meetingStemmableText(item.text)).map((word) => word.stem))
-                        : new Set();
-                    return missing.every((term) => term.stems.some((stem) => stemTokens.has(stem)));
+                const fresh = items.flatMap((item) => {
+                    const corrections = matchMeetingText(tree, item.text, state.stemmer);
+                    if (!corrections)
+                        return [];
+                    return [
+                        corrections.length
+                            ? { ...item, match: "corrected", corrections }
+                            : { ...item, match: "words" },
+                    ];
                 });
                 if (fresh.length !== items.length)
                     coverage.indexing = "pending";
@@ -248,8 +230,9 @@ export function meetingHitSearchOver({ database }) {
                 const hasMore = rows.length > limit;
                 const nextCursor = hasMore && last
                     ? Buffer.from(JSON.stringify({
-                        version: 1,
+                        version: 2,
                         key,
+                        tier: Number(last.tier),
                         started: Number(last.started),
                         meeting: Number(last.meeting_id),
                         kind: Number(last.kind),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.379.0",
+  "version": "0.380.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",
@@ -173,6 +173,7 @@
     "@xmldom/xmldom": "0.9.12",
     "chardet": "2.2.0",
     "defuddle": "0.19.5",
+    "dictionary-ru": "3.0.0",
     "echarts": "6.1.0",
     "fflate": "0.8.3",
     "iconv-lite": "0.7.3",
@@ -202,7 +203,7 @@
     "@types/node": "^22.20.4",
     "@types/pngjs": "6.0.5",
     "@vitest/coverage-v8": "^5.0.2",
-    "@wirecat/cli-base": "0.48.0",
+    "@wirecat/cli-base": "0.49.0",
     "commander": "15.0.0",
     "cspell": "10.3.6",
     "drizzle-kit": "1.0.0-rc.4",
@@ -222,7 +223,7 @@
   },
   "peerDependencies": {
     "@napi-rs/canvas": ">=0.1.69 <2",
-    "@wirecat/cli-base": ">=0.48.0 <0.49.0",
+    "@wirecat/cli-base": ">=0.49.0 <0.50.0",
     "commander": ">=15"
   },
   "bin": {