@rikaidev/yomi 0.4.2 → 0.6.0

package/dist/mcp/names.js

@@ -12,6 +12,20 @@
  * process lifetime. Unresolvable MIDs are never given a fabricated
  * placeholder — callers get `null` and may fall back to the raw MID.
  */
+/**
+ * The name the authenticated user sees for a contact in the LINE app.
+ *
+ * LINE lets users rename friends locally; getContacts returns that name as
+ * `displayNameOverridden` alongside the friend's own `displayName`. The LINE
+ * app shows the override when present, so Yomi should too — otherwise names
+ * an agent reports don't match what the user sees.
+ *
+ * @param contact - Normalized contact from getContacts (may be null).
+ * @returns The user-set name, else the friend's own display name, else null.
+ */
+export function contactDisplayName(contact) {
+    return contact?.displayNameOverridden || contact?.displayName || null;
+}
 /**
  * Resolve display names for LINE user (contact) MIDs.
  *
@@ -35,9 +49,10 @@ export async function resolveUserNames(service, mids) {
     if (missing.length > 0) {
         const contacts = await service.client.getContacts(missing);
         for (const contact of contacts) {
-            if (contact?.mid && contact.displayName) {
-                service.nameCache.set(contact.mid, contact.displayName);
-                resolved.set(contact.mid, contact.displayName);
+            const name = contactDisplayName(contact);
+            if (contact?.mid && name) {
+                service.nameCache.set(contact.mid, name);
+                resolved.set(contact.mid, name);
             }
         }
     }
@@ -106,6 +121,59 @@ async function resolveGroupNames(service, chatIds) {
     }
     return resolved;
 }
+function mentionedUserMids(metadata) {
+    try {
+        const value = typeof metadata?.MENTION === 'string'
+            ? JSON.parse(metadata.MENTION)
+            : metadata?.MENTION;
+        const mentions = value?.MENTIONEES ?? value?.MENTIONS ?? [];
+        return mentions
+            .map((item) => item?.M ?? item?.mid)
+            .filter((mid) => typeof mid === 'string' && mid.startsWith('u'));
+    }
+    catch {
+        return [];
+    }
+}
+/** Legacy rooms have no chatName; LINE presents their participant names. */
+async function resolveRoomNames(service, roomIds) {
+    const resolved = new Map();
+    await Promise.all(Array.from(new Set(roomIds.filter(Boolean))).map(async (roomId) => {
+        const cached = service.chatCache.get(roomId);
+        if (cached?.chatName) {
+            resolved.set(roomId, cached.chatName);
+            return;
+        }
+        try {
+            const messages = await service.getRecentMessages(roomId, 50);
+            const selfMid = service.profile?.mid;
+            const participantMids = Array.from(new Set(messages
+                .flatMap((message) => [
+                message.from,
+                ...mentionedUserMids(message.contentMetadata),
+            ])
+                .filter((mid) => typeof mid === 'string' &&
+                mid.startsWith('u') &&
+                mid !== selfMid)));
+            const names = await resolveUserNames(service, participantMids);
+            const title = participantMids
+                .map((mid) => names.get(mid))
+                .filter((name) => Boolean(name))
+                .slice(0, 4)
+                .join('、');
+            if (!title)
+                return;
+            resolved.set(roomId, title);
+            service.chatCache.set(roomId, {
+                ...(cached ?? {}),
+                chatMid: roomId,
+                chatName: title,
+            });
+        }
+        catch { }
+    }));
+    return resolved;
+}
 /**
  * Resolve a human-readable name for each conversation id, dispatching by
  * LINE's MID prefix convention (u = 1:1 user, c = group, r = room).
@@ -116,18 +184,22 @@ async function resolveGroupNames(service, chatIds) {
  */
 export async function resolveConversationNames(service, chatIds) {
     const userIds = chatIds.filter((id) => id?.startsWith('u'));
-    const groupIds = chatIds.filter((id) => id?.startsWith('c') || id?.startsWith('r'));
-    const [userNames, groupNames] = await Promise.all([
+    const groupIds = chatIds.filter((id) => id?.startsWith('c'));
+    const roomIds = chatIds.filter((id) => id?.startsWith('r'));
+    const [userNames, groupNames, roomNames] = await Promise.all([
         userIds.length > 0
             ? resolveUserNames(service, userIds)
             : Promise.resolve(new Map()),
         groupIds.length > 0
             ? resolveGroupNames(service, groupIds)
             : Promise.resolve(new Map()),
+        roomIds.length > 0
+            ? resolveRoomNames(service, roomIds)
+            : Promise.resolve(new Map()),
     ]);
     const result = new Map();
     for (const id of chatIds) {
-        result.set(id, userNames.get(id) ?? groupNames.get(id) ?? null);
+        result.set(id, userNames.get(id) ?? groupNames.get(id) ?? roomNames.get(id) ?? null);
     }
     return result;
 }

package/dist/mcp/phi-guard.js

@@ -14,7 +14,7 @@
  * extra response content block reporting how many values were masked and of
  * what types, so the redaction is visible rather than a quiet rewrite.
  */
-/** Middle-redaction marker used in masked values (Q12〇〇9 style). */
+/** Middle-redaction marker used in masked values (for example, Q12••9). */
 const MASK_MIDDLE = '〇〇';
 /**
  * Luhn check for candidate payment-card digit strings.
@@ -37,7 +37,7 @@ function passesLuhn(digits) {
     return digits.length >= 13 && digits.length <= 19 && sum % 10 === 0;
 }
 /**
- * Mask one matched value, preserving a little edge context (Q12〇〇9): the
+ * Mask one matched value, preserving a little edge context (for example, Q12••9): the
  * first few characters and, for longer values, the last one.
  * @param value - The raw matched substring.
  * @returns The masked substring.

package/dist/search/bigram.js

@@ -3,11 +3,11 @@
  *
  * The FTS5 `unicode61` tokenizer has no Chinese/Japanese/Korean word
  * segmentation: a whole CJK run collapses into a single opaque token, so a
- * substring like "會議" inside "會議通知" never matches. Yomi has no ICU
+ * two-character CJK substring inside a longer CJK term never matches. Yomi has no ICU
  * tokenizer available and takes on no new dependency to get one, so instead
  * both the indexed text and the search query are rewritten into overlapping
  * character bigrams for CJK runs before ever reaching FTS5. Overlapping
- * bigrams turn "會議通知" into "會議 議通 通知" — searching for "會議"
+ * overlapping bigrams preserve exact two-character search terms inside longer CJK text
  * (itself a single bigram once transformed) becomes a plain token match.
  * This covers the common case of 2+ character CJK words; single-character
  * CJK terms still match via the emitted unigram.

package/dist/search/collector.js

@@ -20,7 +20,7 @@
  * Also batch-embeds each chat's collected messages (when an Embedder is
  * supplied) so semantic search has vectors to rank over. The embedder is
  * always caller-injected — never imported directly here — so the MCP
- * server can pass its DefaultEmbedder while a host app (e.g. inboxd) can
+ * server can pass its DefaultEmbedder while a host app (e.g. Yomi Desktop) can
  * pass its own local model instead. Embedding failure (model unavailable,
  * offline first run, etc.) is caught per-chat and never aborts collection:
  * messages + bigram search_text are always stored regardless of whether

package/dist/search/default-embedder.js

@@ -22,6 +22,8 @@
  * instruction prefix, stored documents do not. Using the model's official
  * recommended instruction for retrieval tasks.
  */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 const MODEL_ID = 'Xenova/bge-small-zh-v1.5';
 const BGE_QUERY_INSTRUCTION = '为这个句子生成表示以用于检索相关文章：';
 let pipelinePromise = null;
@@ -35,9 +37,16 @@ let pipelinePromise = null;
 function getPipeline() {
     if (!pipelinePromise) {
         pipelinePromise = import('@huggingface/transformers')
-            .then(({ pipeline }) => pipeline('feature-extraction', MODEL_ID, {
-            device: 'cpu',
-        }))
+            .then(({ pipeline, env }) => {
+            env.cacheDir =
+                process.env.YOMI_MODEL_CACHE_DIR ||
+                    (process.platform === 'darwin'
+                        ? join(homedir(), 'Library', 'Caches', 'Yomi', 'models')
+                        : join(process.env.LOCALAPPDATA || homedir(), 'Yomi', 'models'));
+            return pipeline('feature-extraction', MODEL_ID, {
+                device: 'cpu',
+            });
+        })
             .catch((error) => {
             // Reset the memo on failure so a later call can retry (e.g. the
             // first attempt failed offline, network comes back later) instead

package/dist/search/embedder.js

@@ -6,7 +6,7 @@
  * a default implementation (./default-embedder.ts, transformers.js/ONNX) so
  * the MCP server works standalone, but nothing in store.ts/collector.ts
  * imports that default directly — they only depend on this interface, so a
- * host app (e.g. inboxd) can inject its own embedder (its local MLX
+ * host app (e.g. Yomi Desktop) can inject its own embedder (its local MLX
  * `generateEmbedding`) instead. See ./default-embedder.ts's doc comment for
  * the exact adapter shape.
  */

package/dist/version.js

@@ -4,4 +4,4 @@
  * virtual filesystem). MUST stay equal to the "version" field in
  * package.json — the test in version.test.ts enforces that.
  */
-export const YOMI_VERSION = '0.4.2';
+export const YOMI_VERSION = '0.6.0';

package/dist/work-item/adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/work-item/destination-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/work-item/event-context.js

@@ -0,0 +1,73 @@
+/**
+ * Expand anchors over the event graph rather than taking a fixed number of
+ * neighbouring messages. Edges are traversed in both directions because a
+ * later delivery can revise the meaning of an earlier request.
+ */
+export function assembleEventContext(allMessages, graph, anchorMessageIds, options = {}) {
+    const minimumWeight = options.minimumEdgeWeight ?? 0.3;
+    const maximumMessages = Math.max(1, options.maximumMessages ?? 64);
+    const byId = new Map(allMessages.map((message) => [message.messageId, message]));
+    const validAnchors = [...new Set(anchorMessageIds)].filter((id) => byId.has(id));
+    const chatId = validAnchors.map((id) => byId.get(id).chatId)[0] ?? '';
+    if (validAnchors.length === 0) {
+        return {
+            schemaVersion: 1,
+            chatId,
+            anchorMessageIds: [],
+            messages: [],
+            edges: [],
+            complete: false,
+            boundary: 'missing_anchor',
+        };
+    }
+    const adjacency = new Map();
+    for (const edge of graph.edges.filter((item) => item.weight >= minimumWeight)) {
+        const parent = byId.get(edge.parentId);
+        const child = byId.get(edge.childId);
+        if (!parent ||
+            !child ||
+            parent.chatId !== chatId ||
+            child.chatId !== chatId)
+            continue;
+        adjacency.set(edge.parentId, [
+            ...(adjacency.get(edge.parentId) ?? []),
+            { id: edge.childId, edge },
+        ]);
+        adjacency.set(edge.childId, [
+            ...(adjacency.get(edge.childId) ?? []),
+            { id: edge.parentId, edge },
+        ]);
+    }
+    const distance = new Map(validAnchors.map((id) => [id, 0]));
+    const queue = [...validAnchors];
+    const includedEdges = new Map();
+    let truncated = false;
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const next of adjacency.get(current) ?? []) {
+            includedEdges.set(`${next.edge.parentId}:${next.edge.childId}`, next.edge);
+            if (distance.has(next.id))
+                continue;
+            if (distance.size >= maximumMessages) {
+                truncated = true;
+                continue;
+            }
+            distance.set(next.id, (distance.get(current) ?? 0) + 1);
+            queue.push(next.id);
+        }
+    }
+    const messages = [...distance.keys()]
+        .map((id) => byId.get(id))
+        .sort((left, right) => left.sentAt - right.sentAt);
+    const selected = new Set(messages.map((message) => message.messageId));
+    const edges = [...includedEdges.values()].filter((edge) => selected.has(edge.parentId) && selected.has(edge.childId));
+    return {
+        schemaVersion: 1,
+        chatId,
+        anchorMessageIds: validAnchors,
+        messages,
+        edges,
+        complete: !truncated,
+        boundary: truncated ? 'message_limit' : 'graph_boundary',
+    };
+}

package/dist/work-item/gold-contract.js

@@ -0,0 +1,101 @@
+const ACTS = new Set([
+    'inform',
+    'ask',
+    'answer',
+    'directive',
+    'commit',
+    'delegate',
+    'acknowledge',
+    'deliver',
+    'accept',
+    'reject',
+    'cancel',
+]);
+const OWNERSHIP = new Set([
+    'unassigned',
+    'owned',
+    'delegated',
+    'unknown',
+]);
+const OWNER_KINDS = new Set([
+    'self',
+    'conversation_member',
+    'external_party',
+    'unknown',
+]);
+const DEPENDENCIES = new Set([
+    'none',
+    'waiting_person',
+    'waiting_external_system',
+    'waiting_decision',
+    'unknown',
+]);
+const LIFECYCLES = new Set([
+    'proposed',
+    'committed',
+    'in_progress',
+    'blocked',
+    'delivered',
+    'accepted',
+    'cancelled',
+    'resolved',
+    'uncertain',
+]);
+export function validateFactorizedGold(value) {
+    const errors = [];
+    if (!value.id)
+        errors.push('id is required');
+    if (!Array.isArray(value.context) || value.context.length === 0)
+        errors.push('context is required');
+    if (!Number.isInteger(value.targetIndex) ||
+        value.targetIndex < 0 ||
+        value.targetIndex >= value.context.length)
+        errors.push('targetIndex is outside context');
+    if (!value.dialogueActs.length ||
+        value.dialogueActs.some((act) => !ACTS.has(act)))
+        errors.push('dialogueActs are invalid');
+    if (value.createsWork && !value.action)
+        errors.push('work requires an action frame');
+    if (!OWNERSHIP.has(value.ownership.state))
+        errors.push('ownership is invalid');
+    if (!Array.isArray(value.ownership.ownerKinds) ||
+        value.ownership.ownerKinds.length === 0 ||
+        value.ownership.ownerKinds.some((kind) => !OWNER_KINDS.has(kind)))
+        errors.push('ownerKinds are invalid');
+    if (!DEPENDENCIES.has(value.dependency))
+        errors.push('dependency is invalid');
+    if (!LIFECYCLES.has(value.lifecycle))
+        errors.push('lifecycle is invalid');
+    if (value.completion.accepted && !value.completion.delivered)
+        errors.push('acceptance requires delivery');
+    if (value.lifecycle === 'delivered' && !value.completion.delivered)
+        errors.push('delivered lifecycle requires delivery evidence');
+    if (value.lifecycle === 'accepted' && !value.completion.accepted)
+        errors.push('accepted lifecycle requires acceptance evidence');
+    if (value.lifecycle === 'cancelled' && !value.completion.cancelled)
+        errors.push('cancelled lifecycle requires cancellation evidence');
+    if (value.evidenceIndexes) {
+        if (value.evidenceIndexes.length === 0)
+            errors.push('evidenceIndexes cannot be empty');
+        if (new Set(value.evidenceIndexes).size !== value.evidenceIndexes.length)
+            errors.push('evidenceIndexes must be unique');
+        if (value.evidenceIndexes.some((index) => !Number.isInteger(index) ||
+            index < 0 ||
+            index >= value.context.length)) {
+            errors.push('evidenceIndexes are outside context');
+        }
+        if (!value.evidenceIndexes.includes(value.targetIndex))
+            errors.push('evidenceIndexes must include targetIndex');
+    }
+    if (value.evidenceMessageIds) {
+        if (value.evidenceMessageIds.length === 0)
+            errors.push('evidenceMessageIds cannot be empty');
+        if (new Set(value.evidenceMessageIds).size !== value.evidenceMessageIds.length)
+            errors.push('evidenceMessageIds must be unique');
+        if (value.evidenceIndexes &&
+            value.evidenceMessageIds.length !== value.evidenceIndexes.length) {
+            errors.push('evidence index and message id counts differ');
+        }
+    }
+    return errors;
+}

package/dist/work-item/gold-coverage.js

@@ -0,0 +1,96 @@
+export const REQUIRED_GOLD_COVERAGE = {
+    work: ['true', 'false'],
+    dialogue: [
+        'inform',
+        'ask',
+        'answer',
+        'directive',
+        'commit',
+        'delegate',
+        'acknowledge',
+        'deliver',
+        'accept',
+        'reject',
+        'cancel',
+    ],
+    ownership: ['unassigned', 'owned', 'delegated'],
+    dependency: [
+        'none',
+        'waiting_person',
+        'waiting_external_system',
+        'waiting_decision',
+    ],
+    lifecycle: [
+        'proposed',
+        'committed',
+        'in_progress',
+        'blocked',
+        'delivered',
+        'accepted',
+        'cancelled',
+        'resolved',
+    ],
+    completion: ['delivered', 'accepted', 'cancelled'],
+};
+export function factorizedCoverageLabels(record) {
+    return [
+        `work:${record.createsWork}`,
+        ...record.dialogueActs.map((label) => `dialogue:${label}`),
+        `ownership:${record.ownership.state}`,
+        `dependency:${record.dependency}`,
+        `lifecycle:${record.lifecycle}`,
+        ...(record.completion.delivered ? ['completion:delivered'] : []),
+        ...(record.completion.accepted ? ['completion:accepted'] : []),
+        ...(record.completion.cancelled ? ['completion:cancelled'] : []),
+    ];
+}
+function count(records, head, label) {
+    if (head === 'work')
+        return records.filter((record) => String(record.createsWork) === label)
+            .length;
+    if (head === 'dialogue')
+        return records.filter((record) => record.dialogueActs.includes(label)).length;
+    if (head === 'ownership')
+        return records.filter((record) => record.ownership.state === label).length;
+    if (head === 'dependency')
+        return records.filter((record) => record.dependency === label).length;
+    if (head === 'lifecycle')
+        return records.filter((record) => record.lifecycle === label).length;
+    return records.filter((record) => record.completion[label]).length;
+}
+/** Every factorized head must be observable; aggregate sample count is not a gate. */
+export function auditGoldCoverage(split) {
+    const issues = [];
+    for (const partition of ['train', 'validation', 'test']) {
+        const records = split[partition];
+        const required = partition === 'train' ? 2 : 1;
+        for (const [head, labels] of Object.entries(REQUIRED_GOLD_COVERAGE)) {
+            for (const label of labels) {
+                const observed = count(records, head, label);
+                if (observed < required)
+                    issues.push({ partition, head, label, observed, required });
+            }
+        }
+    }
+    return issues;
+}
+export function assertGoldCoverage(split) {
+    const issues = auditGoldCoverage(split);
+    if (issues.length > 0) {
+        const summary = issues
+            .map((issue) => `${issue.partition}.${issue.head}.${issue.label}=${issue.observed}/${issue.required}`)
+            .join(', ');
+        throw new Error(`Factorized gold coverage gate failed: ${summary}`);
+    }
+}
+export function auditAcceptanceCoverage(records) {
+    const observed = new Set(records.flatMap(factorizedCoverageLabels));
+    return Object.entries(REQUIRED_GOLD_COVERAGE)
+        .flatMap(([head, labels]) => labels.map((label) => `${head}:${label}`))
+        .filter((label) => !observed.has(label));
+}
+export function assertAcceptanceCoverage(records) {
+    const missing = auditAcceptanceCoverage(records);
+    if (missing.length > 0)
+        throw new Error(`Independent acceptance coverage gate failed: ${missing.join(', ')}`);
+}

package/dist/work-item/gold-derivation.js

@@ -0,0 +1,67 @@
+export function validateGoldDerivation(value) {
+    const errors = [];
+    if (value.schemaVersion !== 1)
+        errors.push('unsupported schemaVersion');
+    if (!value.derivationId)
+        errors.push('derivationId is required');
+    if (!Number.isInteger(value.revision) || value.revision < 1)
+        errors.push('revision must be positive');
+    if (value.revision === 1 && value.previousRevision !== null)
+        errors.push('first revision cannot have a predecessor');
+    if (value.revision > 1 && value.previousRevision !== value.revision - 1)
+        errors.push('revision chain is invalid');
+    if (!value.conversationId)
+        errors.push('conversationId is required');
+    if (!value.graphEventId)
+        errors.push('graphEventId is required');
+    if (value.reasons.length === 0)
+        errors.push('at least one derivation reason is required');
+    if (new Set(value.evidenceMessageIds).size !== value.evidenceMessageIds.length)
+        errors.push('evidenceMessageIds must be unique');
+    if (new Set(value.derivedGoldIds).size !== value.derivedGoldIds.length)
+        errors.push('derivedGoldIds must be unique');
+    if (value.disposition === 'included' && value.derivedGoldIds.length !== 1)
+        errors.push('included context requires exactly one gold record');
+    if (value.disposition === 'split' && value.derivedGoldIds.length < 2)
+        errors.push('split context requires at least two gold records');
+    if (!['included', 'split'].includes(value.disposition) &&
+        value.derivedGoldIds.length > 0)
+        errors.push('excluded context cannot produce gold records');
+    if (!value.contextComplete &&
+        !value.reasons.includes('context_boundary_truncated') &&
+        !value.reasons.includes('missing_antecedent')) {
+        errors.push('incomplete context requires a boundary reason');
+    }
+    return errors;
+}
+export function createGoldDerivation(input) {
+    const revision = {
+        ...input,
+        schemaVersion: 1,
+        revision: 1,
+        previousRevision: null,
+    };
+    const errors = validateGoldDerivation(revision);
+    if (errors.length > 0)
+        throw new Error(errors.join('; '));
+    return revision;
+}
+/** Revisions make exclusions and earlier interpretations explicitly reversible. */
+export function reviseGoldDerivation(previous, input) {
+    if (previous.derivationId !== input.derivationId)
+        throw new Error('Cannot revise a different derivation');
+    if (previous.conversationId !== input.conversationId ||
+        previous.graphEventId !== input.graphEventId) {
+        throw new Error('Derivation source cannot change across revisions');
+    }
+    const revision = {
+        ...input,
+        schemaVersion: 1,
+        revision: previous.revision + 1,
+        previousRevision: previous.revision,
+    };
+    const errors = validateGoldDerivation(revision);
+    if (errors.length > 0)
+        throw new Error(errors.join('; '));
+    return revision;
+}