@rikaidev/yomi 0.5.0 → 0.6.0

package/dist/ambient/summaries/summary-engine.js

@@ -0,0 +1,128 @@
+import { createHash } from 'node:crypto';
+export const CURRENT_SUMMARY_ENGINE_VERSION = 1;
+const EPISODE_GAP_MS = 45 * 60 * 1000; // 45 minutes
+const ROLLUP_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+function computeDigest(content) {
+    return createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+function inferDialogueActs(events) {
+    const acts = new Set();
+    for (const event of events) {
+        const text = event.text ?? '';
+        const isQuestion = /[?？]/.test(text);
+        if (isQuestion) {
+            acts.add('ask');
+        }
+        if (['image', 'video', 'file'].includes(event.contentType)) {
+            acts.add('deliver');
+        }
+        if (event.mentionsSelf || (event.metadata.mentionMids?.length ?? 0) > 0) {
+            acts.add('directive');
+        }
+        if (event.contentType === 'sticker') {
+            acts.add('acknowledge');
+        }
+        if (text.length > 0 && !isQuestion) {
+            acts.add('inform');
+        }
+    }
+    return [...acts];
+}
+export function buildEpisodeSummaries(events, engineVersion = CURRENT_SUMMARY_ENGINE_VERSION) {
+    if (events.length === 0)
+        return [];
+    const byChat = new Map();
+    for (const event of events) {
+        const list = byChat.get(event.chatId) ?? [];
+        list.push(event);
+        byChat.set(event.chatId, list);
+    }
+    const summaries = [];
+    for (const [chatId, chatEvents] of byChat) {
+        const sorted = [...chatEvents].sort((a, b) => a.sentAt - b.sentAt);
+        let currentEpisode = [];
+        const flush = () => {
+            if (currentEpisode.length === 0)
+                return;
+            const minSentAt = currentEpisode[0].sentAt;
+            const maxSentAt = currentEpisode[currentEpisode.length - 1].sentAt;
+            const messageIds = currentEpisode.map((e) => e.messageId);
+            const participantNames = [
+                ...new Set(currentEpisode
+                    .map((e) => e.senderName)
+                    .filter((n) => Boolean(n))),
+            ];
+            const ownerHints = [
+                ...new Set(currentEpisode.flatMap((e) => e.metadata.mentionNames ?? [])),
+            ];
+            const hasMentionsSelf = currentEpisode.some((e) => e.mentionsSelf);
+            const hasQuestions = currentEpisode.some((e) => /[?？]/.test(e.text ?? ''));
+            const hasMedia = currentEpisode.some((e) => ['image', 'video', 'file', 'audio'].includes(e.contentType));
+            const dialogueActs = inferDialogueActs(currentEpisode);
+            const hasSelfQuestion = currentEpisode.some((e) => e.isSelf && /[?？]/.test(e.text ?? ''));
+            const selfQuestionIdx = currentEpisode.findIndex((e) => e.isSelf && /[?？]/.test(e.text ?? ''));
+            const hasReplyAfterSelfQuestion = selfQuestionIdx >= 0 &&
+                currentEpisode.slice(selfQuestionIdx + 1).some((e) => !e.isSelf);
+            const responseState = hasReplyAfterSelfQuestion
+                ? 'received'
+                : hasSelfQuestion
+                    ? 'waiting'
+                    : 'observing';
+            const digest = computeDigest(`${chatId}:${minSentAt}:${messageIds.join(',')}`);
+            const episodeId = `ep-${chatId.slice(0, 8)}-${minSentAt}`;
+            summaries.push({
+                episodeId,
+                chatId,
+                minSentAt,
+                maxSentAt,
+                messageIds,
+                participantNames,
+                dialogueActs,
+                ownerHints,
+                responseState,
+                hasMentionsSelf,
+                hasQuestions,
+                hasMedia,
+                candidateCount: hasMentionsSelf || hasSelfQuestion ? 1 : 0,
+                digest,
+                engineVersion,
+            });
+            currentEpisode = [];
+        };
+        for (const event of sorted) {
+            if (currentEpisode.length > 0 &&
+                event.sentAt - currentEpisode[currentEpisode.length - 1].sentAt >
+                    EPISODE_GAP_MS) {
+                flush();
+            }
+            currentEpisode.push(event);
+        }
+        flush();
+    }
+    return summaries.sort((a, b) => a.minSentAt - b.minSentAt);
+}
+export function buildRollupSummary(windowStart, windowEnd, episodes, engineVersion = CURRENT_SUMMARY_ENGINE_VERSION) {
+    const matching = episodes.filter((ep) => ep.maxSentAt >= windowStart && ep.minSentAt <= windowEnd);
+    const activeChatIds = [...new Set(matching.map((ep) => ep.chatId))];
+    const episodeIds = matching.map((ep) => ep.episodeId);
+    const totalEvents = matching.reduce((sum, ep) => sum + ep.messageIds.length, 0);
+    const unresolvedFrontierCount = matching.filter((ep) => ep.responseState === 'waiting' || ep.hasMentionsSelf).length;
+    const topics = matching
+        .filter((ep) => ep.dialogueActs.length > 0)
+        .map((ep) => `${ep.chatId}:${ep.dialogueActs.join('+')}`)
+        .slice(0, 10);
+    const rollupId = `rollup-${Math.floor(windowStart / ROLLUP_INTERVAL_MS)}`;
+    const digest = computeDigest(`${rollupId}:${episodeIds.join(',')}:${totalEvents}`);
+    return {
+        rollupId,
+        windowStart,
+        windowEnd,
+        activeChatIds,
+        episodeIds,
+        totalEvents,
+        unresolvedFrontierCount,
+        topics,
+        digest,
+        engineVersion,
+    };
+}

package/dist/ambient/summaries/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for Hierarchical Summaries (10-minute Episodes & 6-hour Rollups).
+ */
+export {};

package/dist/attention/policy.js

@@ -49,23 +49,29 @@ export async function scoreAttentionBatch(inputs, embedder = getDefaultEmbedder(
     const messageVectors = vectors.slice(anchors.length);
     return inputs.map((input, inputIndex) => {
         if (input.isMuted)
-            return { score: -100, tier: 'filtered', reason: '已靜音' };
+            return { score: -100, tier: 'filtered', reason: 'muted' };
         if (input.explicitPriority)
-            return { score: 70, tier: 'now', reason: '使用者標記優先' };
+            return { score: 70, tier: 'now', reason: 'manual_priority' };
         if (input.hasMention)
-            return { score: 65, tier: 'now', reason: '直接提及你' };
+            return { score: 65, tier: 'now', reason: 'direct_mention' };
+        if (input.isOfficial &&
+            /^\[yomi:(?:image|rich|sticker|video|audio|file|extended_image)\]$/.test(input.text.trim())) {
+            return { score: 0, tier: 'filtered', reason: 'ordinary' };
+        }
         const similarities = new Map();
         anchors.forEach((anchor, anchorIndex) => {
             const similarity = dot(messageVectors[inputIndex], anchorVectors[anchorIndex]);
             similarities.set(anchor.intent, Math.max(similarities.get(anchor.intent) ?? -Infinity, similarity));
         });
         const ranked = [...intents].sort((a, b) => (similarities.get(b) ?? 0) - (similarities.get(a) ?? 0));
-        let intent = ranked[0];
-        // Broadcast accounts commonly announce dated events and use rhetorical
-        // questions. Only a transaction/account/service state tied to the user may
-        // elevate them; generic events are not the user's deadline.
-        if (input.isOfficial && intent !== 'transaction')
-            intent = 'promotion';
+        const intent = ranked[0];
+        if (input.isOfficial && intent !== 'transaction') {
+            return {
+                score: -40,
+                tier: 'filtered',
+                reason: intent === 'promotion' ? 'promotion' : 'ordinary',
+            };
+        }
         const scoreByIntent = {
             reply: 55,
             deadline: 60,
@@ -74,7 +80,7 @@ export async function scoreAttentionBatch(inputs, embedder = getDefaultEmbedder(
             ordinary: 0,
             promotion: -40,
         };
-        const score = scoreByIntent[intent] + (input.unreadCount > 0 ? 5 : 0);
+        const score = scoreByIntent[intent];
         const tier = score >= 55
             ? 'now'
             : score >= 35
@@ -83,12 +89,12 @@ export async function scoreAttentionBatch(inputs, embedder = getDefaultEmbedder(
                     ? 'know'
                     : 'filtered';
         const reasons = {
-            reply: '對方可能在等你回覆',
-            deadline: '有期限、行程或緊急事項',
-            transaction: '與你的交易或服務狀態有關',
-            important: '重要資訊，但不需立即回覆',
-            ordinary: '一般資訊，沒有明確下一步',
-            promotion: '官方宣傳或與你較無關',
+            reply: 'reply_expected',
+            deadline: 'deadline',
+            transaction: 'transaction',
+            important: 'important',
+            ordinary: 'ordinary',
+            promotion: 'promotion',
         };
         return { score, tier, reason: reasons[intent] };
     });

package/dist/auth/credential-store.js

@@ -86,7 +86,7 @@ class VolatileCacheStore {
     cache = new Map();
     loaded = false;
     dirty = false;
-    writing = false;
+    flushPromise = null;
     constructor(filePath) {
         this.filePath = filePath;
     }
@@ -139,11 +139,10 @@ class VolatileCacheStore {
     /** Coalesce bursts of writes into a single atomic flush cycle. */
     scheduleFlush() {
         this.dirty = true;
-        if (this.writing) {
+        if (this.flushPromise) {
             return;
         }
-        this.writing = true;
-        void (async () => {
+        this.flushPromise = (async () => {
             const fs = await import('node:fs/promises');
             while (this.dirty) {
                 this.dirty = false;
@@ -169,8 +168,13 @@ class VolatileCacheStore {
                     // Best-effort cache persistence; in-memory copy still serves reads.
                 }
             }
-            this.writing = false;
-        })();
+        })().finally(() => {
+            this.flushPromise = null;
+        });
+    }
+    async flush() {
+        while (this.flushPromise)
+            await this.flushPromise;
     }
 }
 /**
@@ -361,6 +365,11 @@ export class CredentialStore {
             return persisted;
         });
     }
+    /** Await durable and volatile write queues, primarily for orderly shutdown. */
+    async flush() {
+        await this.persistQueue;
+        await this.volatile.flush();
+    }
     /**
      * Delete a credential and persist.
      * @param key - Credential key to delete.