@rikaidev/yomi 0.2.6

package/dist/mcp/handlers/message-actions.js

@@ -0,0 +1,62 @@
+import { createCliLogger } from '../../util/log.js';
+import { jsonResult, toolError } from './shared.js';
+const log = createCliLogger('Yomi');
+/**
+ * Handle `react_message` — REALLY adds a predefined reaction to a real LINE
+ * message now (TalkService react). Visible to the conversation. `reactionType`:
+ * 2=LIKE 👍, 3=LOVE ❤️, 4=LAUGH 😆, 5=SURPRISE 😮, 6=SAD 😢, 7=ANGRY 😡
+ * (default 2).
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result.
+ */
+export async function handleReactMessage(service, args) {
+    if (!args.messageId) {
+        return toolError('messageId is required.');
+    }
+    const result = await service.reactToMessage(args.messageId, args.reactionType);
+    log.info('react_message.done', {
+        messageId: args.messageId,
+        reactionType: result?.reactionType,
+    });
+    return jsonResult(result);
+}
+/**
+ * Handle `unsend_message` — REALLY retracts one of THIS account's own messages
+ * for everyone (TalkService unsendMessage). This deletes the message from the
+ * conversation for all participants and is NOT reversible. Guarded by an
+ * explicit `confirm: true` gate so it can never fire by accident. LINE only
+ * permits unsending the caller's own messages.
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result.
+ */
+export async function handleUnsendMessage(service, args) {
+    if (!args.messageId) {
+        return toolError('messageId is required.');
+    }
+    if (args.confirm !== true) {
+        return toolError('unsend_message permanently retracts your message for everyone and cannot be undone. Re-call with confirm: true to proceed.');
+    }
+    const result = await service.unsendMessage(args.messageId);
+    log.info('unsend_message.done', { messageId: args.messageId });
+    return jsonResult(result);
+}
+/**
+ * Handle `cancel_reaction` — REALLY removes THIS account's reaction from a real
+ * LINE message now (TalkService cancelReaction).
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result.
+ */
+export async function handleCancelReaction(service, args) {
+    if (!args.messageId) {
+        return toolError('messageId is required.');
+    }
+    const result = await service.cancelReaction(args.messageId);
+    log.info('cancel_reaction.done', { messageId: args.messageId });
+    return jsonResult(result);
+}

package/dist/mcp/handlers/scope.js

@@ -0,0 +1,120 @@
+/**
+ * Yomi conversation-scoping MCP tool handlers — exclude_chats,
+ * include_chats, list_excluded_chats, get_scope_policy.
+ *
+ * Split out from handlers.ts (mirrors the search-handlers.ts split) to keep
+ * that file under the project's 500-scc-line module cap. These are
+ * LOCAL-INDEX operations over the denylist in ../search/scope.ts: they read
+ * and write the same search-index.db that ../search/collector.ts and
+ * ../search/store.ts own, and never require a live LINE session except to
+ * best-effort resolve display names in list_excluded_chats/get_scope_policy.
+ */
+import { addExcludedChatIds, deleteMessagesForChats, getExcludedChatIds, removeExcludedChatIds, } from '../../search/scope.js';
+import { resolveConversationNames } from '../names.js';
+import { getPrivacyPolicyText } from '../policy.js';
+import { toolError } from './shared.js';
+/**
+ * Read the current exclusion denylist and pair each chatId with a
+ * best-effort display name. Name resolution only runs when a live LINE
+ * session exists (`service.client`); without one, or when a name is
+ * otherwise unresolvable, `name` is `null` rather than a fabricated
+ * placeholder. Shared by list_excluded_chats and get_scope_policy so the
+ * two never drift.
+ *
+ * @param service - LineProtocolService; `service.client` is used only for
+ *   name resolution and may be absent.
+ * @returns Excluded conversations, each `{ chatId, name }`.
+ */
+async function listExcludedChatsWithNames(service) {
+    const chatIds = Array.from(getExcludedChatIds());
+    if (chatIds.length === 0) {
+        return [];
+    }
+    const names = service.client
+        ? await resolveConversationNames(service, chatIds)
+        : new Map();
+    return chatIds.map((chatId) => ({ chatId, name: names.get(chatId) ?? null }));
+}
+/**
+ * Handle `exclude_chats` — add chatIds to the scoping denylist AND purge
+ * their already-indexed messages/embeddings. Both effects happen together:
+ * excluding a chat is meant to remove what Yomi already learned about it,
+ * not just stop learning more (see ../search/scope.ts).
+ *
+ * @param args - Tool arguments.
+ * @returns MCP tool result with `{ excluded, purgedMessages }`.
+ */
+export async function handleExcludeChats(args) {
+    if (!args.chatIds || args.chatIds.length === 0) {
+        return toolError('chatIds is required and must be a non-empty array.');
+    }
+    const excluded = addExcludedChatIds(args.chatIds);
+    const purgedMessages = deleteMessagesForChats(args.chatIds);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({ excluded, purgedMessages }, null, 2),
+            },
+        ],
+    };
+}
+/**
+ * Handle `include_chats` — remove chatIds from the scoping denylist,
+ * re-allowing future capture. Does NOT re-fetch or restore any previously
+ * purged data; the next `collect_messages`/`search_messages` auto-collect
+ * picks the chat back up going forward.
+ *
+ * @param args - Tool arguments.
+ * @returns MCP tool result with `{ included }`.
+ */
+export async function handleIncludeChats(args) {
+    if (!args.chatIds || args.chatIds.length === 0) {
+        return toolError('chatIds is required and must be a non-empty array.');
+    }
+    const included = removeExcludedChatIds(args.chatIds);
+    return {
+        content: [
+            { type: 'text', text: JSON.stringify({ included }, null, 2) },
+        ],
+    };
+}
+/**
+ * Handle `list_excluded_chats` — the current scoping denylist, with
+ * best-effort display-name resolution when a live LINE session exists.
+ * Without a session (or when a name is otherwise unresolvable), `name` is
+ * `null` rather than a fabricated placeholder.
+ *
+ * @param service - LineProtocolService; `service.client` is used only for
+ *   name resolution and may be absent.
+ * @returns MCP tool result with `[{ chatId, name }]`.
+ */
+export async function handleListExcludedChats(service) {
+    const result = await listExcludedChatsWithNames(service);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+/**
+ * Handle `get_scope_policy` — return Yomi's data-capture privacy policy (the
+ * disclosure the agent should surface to the user) alongside the current
+ * exclusion list. The policy prose comes from the canonical PRIVACY.md via
+ * getPrivacyPolicyText (single source of truth — never duplicated here).
+ * Reuses the same best-effort name resolution as list_excluded_chats via
+ * listExcludedChatsWithNames, so names appear only when a live LINE session
+ * exists, else `null`.
+ *
+ * @param service - LineProtocolService; `service.client` is used only for
+ *   name resolution and may be absent.
+ * @returns MCP tool result with `{ policy, excludedChats }`.
+ */
+export async function handleGetScopePolicy(service) {
+    const excludedChats = await listExcludedChatsWithNames(service);
+    const result = {
+        policy: getPrivacyPolicyText(),
+        excludedChats,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}

package/dist/mcp/handlers/search.js

@@ -0,0 +1,196 @@
+/**
+ * Yomi cross-conversation search tool handlers — collect_messages and
+ * search_messages.
+ *
+ * Split out from handlers.ts because these two tools are the boundary
+ * between the pure-query LINE tools (handlers.ts) and the local search
+ * index in ../search/ (see store.ts, collector.ts): collect_messages
+ * writes to that index, search_messages reads from it. No other tool
+ * touches the index.
+ *
+ * search_messages is HYBRID: it always runs FTS5 keyword search (bigram-
+ * preprocessed, so it covers every indexed message and guarantees exact
+ * substring matches are never lost) and, when embeddings exist for the
+ * current model, also runs semantic search (cosine similarity over
+ * transformers.js embeddings, see ../search/default-embedder.ts). The two
+ * ranked lists are fused by Reciprocal Rank Fusion (see fuseByRrf) so a
+ * result that either method ranks highly surfaces near the top. This is
+ * deliberately not "semantic OR keyword": pure semantic over a partially-
+ * embedded index silently drops exact matches that live in un-embedded
+ * messages (the "search 台東 misses the chat that literally says 台東" bug),
+ * and pure keyword misses paraphrases. Which methods actually contributed
+ * is always reported via the `mode` field (`hybrid` | `semantic` |
+ * `keyword`), never hidden.
+ */
+import { collectMessages } from '../../search/collector.js';
+import { getDefaultEmbedder } from '../../search/default-embedder.js';
+import { getEmbeddingCount, getIndexedMessageCount, searchMessages, semanticSearch, } from '../../search/store.js';
+import { createCliLogger } from '../../util/log.js';
+import { createPhiAccumulator, maskInto, phiNote } from '../phi-guard.js';
+import { toolError } from './shared.js';
+const log = createCliLogger('Yomi');
+/**
+ * Reciprocal Rank Fusion constant. The standard k=60 from Cormack et al.:
+ * a result's contribution from one list is 1/(k + rank), so rank matters
+ * but no single list can dominate on raw score scale (bm25's negative log
+ * scores and cosine's [0,1] are never compared directly — only their
+ * ranks are). Larger k flattens the rank curve; 60 is the well-tested default.
+ */
+const RRF_K = 60;
+/**
+ * Merge several already-ranked result lists into one, deduping by
+ * messageId, using Reciprocal Rank Fusion. Each list contributes
+ * 1/(RRF_K + rank) to a message's fused score; scores sum across lists, so
+ * a message ranked highly by BOTH keyword and semantic search rises above
+ * one ranked highly by only one. The returned `score` is the fused RRF
+ * score (NOT a cosine similarity or bm25 value) — it exists only to order
+ * results, and is reported as-is rather than dressed up as a probability.
+ *
+ * @param lists - Ranked result lists (best-first) to fuse.
+ * @param limit - Maximum number of fused results to return.
+ * @returns Fused results, best-first, each carrying its RRF score.
+ */
+function fuseByRrf(lists, limit) {
+    const scores = new Map();
+    const rows = new Map();
+    for (const list of lists) {
+        list.forEach((row, rank) => {
+            scores.set(row.messageId, (scores.get(row.messageId) ?? 0) + 1 / (RRF_K + rank));
+            if (!rows.has(row.messageId)) {
+                rows.set(row.messageId, row);
+            }
+        });
+    }
+    return [...scores.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit)
+        .map(([messageId, score]) => ({
+        ...rows.get(messageId),
+        score,
+    }));
+}
+/**
+ * Handle `collect_messages` — explicit bulk fetch of recent messages from
+ * one or more LINE conversations into the local search index, batch-
+ * embedding each chat's messages with the default embedder along the way
+ * (best-effort — see ../search/collector.ts's embedAndStore for the
+ * failure-never-blocks-collection guarantee). The only tool allowed to
+ * bulk-fetch across chats; runs exactly once per call.
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result summarizing what was indexed and embedded.
+ */
+export async function handleCollectMessages(service, args) {
+    const summary = await collectMessages(service, {
+        chatIds: args.chatIds,
+        perChat: args.perChat,
+        embedder: getDefaultEmbedder(),
+    });
+    return {
+        content: [
+            { type: 'text', text: JSON.stringify(summary, null, 2) },
+        ],
+    };
+}
+/**
+ * Handle `search_messages` — hybrid keyword + semantic search, fused by
+ * Reciprocal Rank Fusion (see fuseByRrf). Keyword search always runs and
+ * covers every indexed message, so exact matches are never dropped;
+ * semantic search additionally runs whenever vectors exist for the current
+ * model, adding paraphrase recall. `mode` reports which methods contributed.
+ *
+ * Auto-collects on an empty index: the first search with a live session
+ * transparently runs a full `collect_messages` across all conversations
+ * before searching, so callers never have to know `collect_messages`
+ * exists — searching "just works" out of the box. This is the one place
+ * search itself may hit LINE; a non-empty index searches locally with no
+ * network. Ongoing freshness is not this handler's job: the background
+ * capture loop (see ../search/capture.ts) indexes incoming messages as they
+ * arrive, so the index stays current without search re-collecting on every
+ * query (which would cost tens of seconds of latency — not any rate limit,
+ * which we have never observed). With an empty index and no session, it says
+ * so honestly rather than returning a silently empty result.
+ *
+ * @param service - Resumed LineProtocolService (used only to auto-collect an empty index).
+ * @param args - Tool arguments.
+ * @returns MCP tool result with `{ mode, results }`, or an honest notice.
+ */
+export async function handleSearchMessages(service, args) {
+    if (!args.query) {
+        return toolError('query is required.');
+    }
+    if (getIndexedMessageCount() === 0) {
+        if (!service.client) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Search index is empty and there is no LINE session — log in first; the index then builds automatically on your next search.',
+                    },
+                ],
+            };
+        }
+        log.info('search.auto_collect', { reason: 'empty_index' });
+        const summary = await collectMessages(service, {
+            embedder: getDefaultEmbedder(),
+        });
+        log.info('search.auto_collect_done', { ...summary });
+        if (getIndexedMessageCount() === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Nothing to search — auto-collect found no readable messages across your conversations.',
+                    },
+                ],
+            };
+        }
+    }
+    const limit = args.limit ?? 20;
+    // Pull a deeper candidate pool from each method than the caller's limit,
+    // so RRF has enough overlap/depth to reorder meaningfully before slicing.
+    const pool = Math.max(limit * 3, 30);
+    const embedder = getDefaultEmbedder();
+    const keyword = searchMessages(args.query, pool);
+    let semantic = [];
+    if (getEmbeddingCount(embedder.modelLabel) > 0) {
+        try {
+            semantic = await semanticSearch(args.query, pool, embedder);
+        }
+        catch (error) {
+            log.warn('search.semantic_failed', {
+                error: error?.message ?? String(error),
+            });
+        }
+    }
+    let mode;
+    let results;
+    if (semantic.length > 0 && keyword.length > 0) {
+        mode = 'hybrid';
+        results = fuseByRrf([keyword, semantic], limit);
+    }
+    else if (semantic.length > 0) {
+        mode = 'semantic';
+        results = semantic.slice(0, limit);
+    }
+    else {
+        mode = 'keyword';
+        results = keyword.slice(0, limit);
+    }
+    const acc = createPhiAccumulator();
+    const maskedResults = results.map((row) => ({
+        ...row,
+        text: maskInto(acc, row.text),
+    }));
+    const content = [
+        {
+            type: 'text',
+            text: JSON.stringify({ mode, results: maskedResults }, null, 2),
+        },
+    ];
+    const note = phiNote(acc);
+    if (note)
+        content.push(note);
+    return { content };
+}