@rikaidev/yomi 0.4.2 → 0.6.0

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

@@ -0,0 +1,143 @@
+function labelsFor(record) {
+    return [
+        `work:${record.createsWork}`,
+        ...record.dialogueActs.map((value) => `dialogue:${value}`),
+        `ownership:${record.ownership.state}`,
+        ...record.ownership.ownerKinds.map((value) => `owner_kind:${value}`),
+        `dependency:${record.dependency}`,
+        `lifecycle:${record.lifecycle}`,
+        `completion:delivered:${record.completion.delivered}`,
+        `completion:accepted:${record.completion.accepted}`,
+        `completion:cancelled:${record.completion.cancelled}`,
+    ];
+}
+function labelCounts(records) {
+    const counts = new Map();
+    for (const record of records) {
+        for (const label of labelsFor(record))
+            counts.set(label, (counts.get(label) ?? 0) + 1);
+    }
+    return counts;
+}
+function stableHash(value) {
+    let hash = 0x811c9dc5;
+    for (const character of value) {
+        hash ^= character.codePointAt(0) ?? 0;
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+function conversationId(record) {
+    return record.source?.chatId ?? `synthetic:${record.id}`;
+}
+/**
+ * Assign whole conversations, never windows, to partitions. Public acceptance
+ * fixtures are removed before grouping so they cannot leak into model fitting.
+ */
+export function splitFactorizedGoldByConversation(records, options) {
+    const acceptance = new Set(options.acceptanceIds ?? []);
+    const excludedAcceptanceIds = [];
+    const groups = new Map();
+    for (const record of records) {
+        if (acceptance.has(record.id)) {
+            excludedAcceptanceIds.push(record.id);
+            continue;
+        }
+        const key = conversationId(record);
+        groups.set(key, [...(groups.get(key) ?? []), record]);
+    }
+    const validationFraction = options.validationFraction ?? 0.15;
+    const testFraction = options.testFraction ?? 0.15;
+    if (validationFraction < 0 ||
+        testFraction < 0 ||
+        validationFraction + testFraction >= 1) {
+        throw new Error('Invalid split fractions');
+    }
+    const validationGroups = groups.size >= 3
+        ? Math.max(1, Math.round(groups.size * validationFraction))
+        : 0;
+    const testGroups = groups.size >= 3 ? Math.max(1, Math.round(groups.size * testFraction)) : 0;
+    const trainGroups = Math.max(0, groups.size - validationGroups - testGroups);
+    const allRecords = [...groups.values()].flat();
+    const totals = labelCounts(allRecords);
+    const shares = {
+        train: 1 - validationFraction - testFraction,
+        validation: validationFraction,
+        test: testFraction,
+    };
+    const capacities = {
+        train: trainGroups,
+        validation: validationGroups,
+        test: testGroups,
+    };
+    const assigned = {
+        train: [],
+        validation: [],
+        test: [],
+    };
+    const assignedGroups = { train: 0, validation: 0, test: 0 };
+    const current = {
+        train: new Map(),
+        validation: new Map(),
+        test: new Map(),
+    };
+    const ordered = [...groups.entries()].sort(([leftId, left], [rightId, right]) => {
+        const rarity = (records) => [...new Set(records.flatMap(labelsFor))].reduce((sum, label) => sum + 1 / (totals.get(label) ?? 1), 0);
+        return (rarity(right) - rarity(left) ||
+            stableHash(`${options.seed}:${leftId}`) -
+                stableHash(`${options.seed}:${rightId}`));
+    });
+    for (const [groupId, records] of ordered) {
+        const counts = labelCounts(records);
+        const candidates = ['train', 'validation', 'test'].filter((name) => assignedGroups[name] < capacities[name]);
+        const scored = candidates
+            .map((name) => {
+            let labelNeed = 0;
+            for (const [label, count] of counts) {
+                const target = (totals.get(label) ?? 0) * shares[name];
+                labelNeed +=
+                    (count * Math.max(0, target - (current[name].get(label) ?? 0))) /
+                        Math.max(1, target);
+            }
+            const targetRecords = allRecords.length * shares[name];
+            const sizeNeed = Math.max(0, targetRecords - assigned[name].length) /
+                Math.max(1, targetRecords);
+            return {
+                name,
+                score: labelNeed * 4 + sizeNeed,
+                tie: stableHash(`${options.seed}:${groupId}:${name}`),
+            };
+        })
+            .sort((left, right) => right.score - left.score || left.tie - right.tie);
+        const destination = scored[0]?.name;
+        if (!destination)
+            throw new Error('No partition has remaining conversation capacity');
+        assigned[destination].push(...records);
+        assignedGroups[destination] += 1;
+        for (const [label, count] of counts)
+            current[destination].set(label, (current[destination].get(label) ?? 0) + count);
+    }
+    return {
+        seed: options.seed,
+        train: assigned.train,
+        validation: assigned.validation,
+        test: assigned.test,
+        excludedAcceptanceIds: excludedAcceptanceIds.sort(),
+    };
+}
+export function assertNoConversationLeakage(split) {
+    const seen = new Map();
+    for (const [partition, records] of Object.entries({
+        train: split.train,
+        validation: split.validation,
+        test: split.test,
+    })) {
+        for (const record of records) {
+            const key = conversationId(record);
+            const previous = seen.get(key);
+            if (previous && previous !== partition)
+                throw new Error(`Conversation ${key} leaked from ${previous} into ${partition}`);
+            seen.set(key, partition);
+        }
+    }
+}

package/dist/work-item/index.js

@@ -0,0 +1,23 @@
+export * from './adapter.js';
+export * from './destination-contracts.js';
+export * from './event-context.js';
+export * from './gold-contract.js';
+export * from './gold-coverage.js';
+export * from './gold-derivation.js';
+export * from './gold-split.js';
+export * from './line-adapter.js';
+export * from './llama-cpp-work-event-adapter.js';
+export * from './local-provider.js';
+export * from './local-work-event-provider.js';
+export * from './onnx-work-event-adapter.js';
+export * from './provider.js';
+export * from './registry.js';
+export * from './service.js';
+export * from './store.js';
+export * from './types.js';
+export * from './work-event.js';
+export * from './work-event-graph-engine.js';
+export * from './work-event-inference.js';
+export * from './work-event-matcher.js';
+export * from './work-event-model-manifest.js';
+export * from './work-event-store.js';

package/dist/work-item/line-adapter.js

@@ -0,0 +1,111 @@
+import { createHash } from 'node:crypto';
+function asBytes(bytes) {
+    if (!bytes)
+        return undefined;
+    return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+}
+function normalizeAttachment(input, messageId, index) {
+    const bytes = asBytes(input.bytes);
+    return {
+        id: String(input.id ?? `${messageId}:attachment:${index}`),
+        fileName: input.fileName ?? null,
+        mimeType: input.mimeType ?? input.mediaType ?? null,
+        byteLength: input.byteLength ?? input.size ?? bytes?.byteLength ?? null,
+        sha256: bytes ? createHash('sha256').update(bytes).digest('hex') : null,
+        ...(bytes ? { bytes } : {}),
+        ...(input.url || input.mediaUrl
+            ? { sourceUrl: input.url ?? input.mediaUrl ?? undefined }
+            : {}),
+    };
+}
+function messageAttachments(input, messageId) {
+    const values = [
+        ...(input.attachments ?? []),
+        ...(input.attachment ? [input.attachment] : []),
+    ];
+    if (values.length === 0 && (input.mediaUrl || input.fileName)) {
+        values.push({
+            fileName: input.fileName,
+            mediaType: input.mediaType,
+            mediaUrl: input.mediaUrl,
+        });
+    }
+    return values.map((item, index) => normalizeAttachment(item, messageId, index));
+}
+export function isLineWorkItemMessage(input) {
+    return (typeof input === 'object' &&
+        input !== null &&
+        (typeof input.id === 'string' ||
+            typeof input.id === 'number'));
+}
+export class LineWorkItemAdapter {
+    id = 'line.message';
+    platform = 'line';
+    canNormalize(input) {
+        return (isLineWorkItemMessage(input) ||
+            (Array.isArray(input) && input.every(isLineWorkItemMessage)));
+    }
+    normalize(input) {
+        const inputs = Array.isArray(input) ? [...input] : [input];
+        if (inputs.length === 0)
+            throw new Error('LINE work item requires at least one message');
+        const normalized = inputs.map((message) => {
+            const messageId = String(message.id);
+            const conversationId = String(message.conversationId ?? message.chatId ?? '');
+            if (!conversationId)
+                throw new Error('LINE work item requires conversationId');
+            const sentAt = message.timestamp ?? Date.now();
+            const source = {
+                adapter: this.id,
+                platform: this.platform,
+                conversationId,
+                messageIds: [messageId],
+                latestMessageAt: sentAt,
+            };
+            return {
+                conversationId,
+                evidence: {
+                    source,
+                    sourceMessageId: messageId,
+                    senderId: message.senderId ?? message.fromMid ?? null,
+                    senderName: message.senderName ?? message.fromName ?? null,
+                    sentAt,
+                    text: message.text ?? message.content ?? null,
+                    attachments: messageAttachments(message, messageId),
+                },
+            };
+        });
+        const seen = new Set();
+        const evidence = normalized
+            .sort((a, b) => a.evidence.sentAt - b.evidence.sentAt ||
+            a.evidence.sourceMessageId.localeCompare(b.evidence.sourceMessageId))
+            .flatMap((message) => {
+            const key = `${message.conversationId}:${message.evidence.sourceMessageId}`;
+            if (seen.has(key))
+                return [];
+            seen.add(key);
+            return [message.evidence];
+        });
+        const sourceByConversation = new Map();
+        for (const item of evidence) {
+            const itemSource = item.source;
+            const existing = sourceByConversation.get(itemSource.conversationId);
+            if (existing) {
+                existing.messageIds.push(...itemSource.messageIds);
+                existing.latestMessageAt = Math.max(existing.latestMessageAt, itemSource.latestMessageAt);
+            }
+            else {
+                sourceByConversation.set(itemSource.conversationId, {
+                    ...itemSource,
+                    messageIds: [...itemSource.messageIds],
+                });
+            }
+        }
+        const sources = [...sourceByConversation.values()];
+        return {
+            source: sources[0],
+            sources,
+            evidence,
+        };
+    }
+}

package/dist/work-item/llama-cpp-work-event-adapter.js

@@ -0,0 +1,239 @@
+const ACTS = [
+    'inform',
+    'ask',
+    'answer',
+    'directive',
+    'commit',
+    'delegate',
+    'acknowledge',
+    'deliver',
+    'accept',
+    'reject',
+    'cancel',
+];
+const OWNER_STATES = ['unassigned', 'owned', 'delegated', 'unknown'];
+const PARTICIPANT_KINDS = [
+    'self',
+    'conversation_member',
+    'external_party',
+    'unknown',
+];
+const DEPENDENCIES = [
+    'none',
+    'waiting_person',
+    'waiting_external_system',
+    'waiting_decision',
+    'unknown',
+];
+const LIFECYCLES = [
+    'proposed',
+    'committed',
+    'in_progress',
+    'blocked',
+    'delivered',
+    'accepted',
+    'cancelled',
+    'resolved',
+    'uncertain',
+];
+const evidenceField = {
+    type: 'object',
+    required: ['confidence', 'evidenceMessageIds'],
+    properties: {
+        confidence: { type: 'number', minimum: 0, maximum: 1 },
+        evidenceMessageIds: { type: 'array', items: { type: 'string' } },
+    },
+};
+export const WORK_EVENT_GRAPH_JSON_SCHEMA = {
+    type: 'object',
+    required: ['dialogue', 'candidates'],
+    properties: {
+        dialogue: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: ['messageId', 'acts', 'confidence'],
+                properties: {
+                    messageId: { type: 'string' },
+                    acts: {
+                        type: 'array',
+                        minItems: 1,
+                        items: { type: 'string', enum: ACTS },
+                    },
+                    confidence: { type: 'number', minimum: 0, maximum: 1 },
+                },
+            },
+        },
+        candidates: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: [
+                    'candidateKey',
+                    'createsWork',
+                    'action',
+                    'ownership',
+                    'dependency',
+                    'lifecycle',
+                    'completion',
+                ],
+                properties: {
+                    candidateKey: { type: 'string' },
+                    createsWork: {
+                        ...evidenceField,
+                        required: ['value', 'confidence', 'evidenceMessageIds'],
+                        properties: {
+                            ...evidenceField.properties,
+                            value: { type: 'boolean' },
+                        },
+                    },
+                    action: {
+                        anyOf: [
+                            { type: 'null' },
+                            {
+                                type: 'object',
+                                required: [
+                                    'predicate',
+                                    'object',
+                                    'expectedOutcome',
+                                    'dueAt',
+                                    'sourceMessageIds',
+                                    'confidence',
+                                ],
+                                properties: {
+                                    predicate: { type: 'string' },
+                                    object: { type: ['string', 'null'] },
+                                    expectedOutcome: { type: ['string', 'null'] },
+                                    dueAt: { type: ['number', 'null'] },
+                                    sourceMessageIds: {
+                                        type: 'array',
+                                        minItems: 1,
+                                        items: { type: 'string' },
+                                    },
+                                    confidence: { type: 'number', minimum: 0, maximum: 1 },
+                                },
+                            },
+                        ],
+                    },
+                    ownership: {
+                        ...evidenceField,
+                        required: ['value', 'confidence', 'evidenceMessageIds'],
+                        properties: {
+                            ...evidenceField.properties,
+                            value: {
+                                type: 'object',
+                                required: ['state', 'owners'],
+                                properties: {
+                                    state: { type: 'string', enum: OWNER_STATES },
+                                    owners: {
+                                        type: 'array',
+                                        items: {
+                                            type: 'object',
+                                            required: ['kind', 'stableId', 'displayName'],
+                                            properties: {
+                                                kind: { type: 'string', enum: PARTICIPANT_KINDS },
+                                                stableId: { type: ['string', 'null'] },
+                                                displayName: { type: ['string', 'null'] },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    dependency: {
+                        ...evidenceField,
+                        required: ['value', 'confidence', 'evidenceMessageIds'],
+                        properties: {
+                            ...evidenceField.properties,
+                            value: {
+                                type: 'object',
+                                required: ['state', 'on'],
+                                properties: {
+                                    state: { type: 'string', enum: DEPENDENCIES },
+                                    on: { type: ['object', 'null'] },
+                                },
+                            },
+                        },
+                    },
+                    lifecycle: {
+                        ...evidenceField,
+                        required: ['value', 'confidence', 'evidenceMessageIds'],
+                        properties: {
+                            ...evidenceField.properties,
+                            value: { type: 'string', enum: LIFECYCLES },
+                        },
+                    },
+                    completion: {
+                        ...evidenceField,
+                        required: ['value', 'confidence', 'evidenceMessageIds'],
+                        properties: {
+                            ...evidenceField.properties,
+                            value: {
+                                type: 'object',
+                                required: ['delivered', 'accepted', 'cancelled'],
+                                properties: {
+                                    delivered: { type: 'boolean' },
+                                    accepted: { type: 'boolean' },
+                                    cancelled: { type: 'boolean' },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+const SYSTEM_PROMPT = `Infer a revisable work-event graph from the complete event context. Dialogue acts are message-level. Return zero or more distinct candidates; one message may cancel one action and propose another, so candidates may share evidence. Information and answers can create work. Acknowledgement is not acceptance. Never infer work from read state, names, or account identity. Action frames must cite source message IDs. If uncertain, use low confidence rather than inventing evidence.`;
+export class LlamaCppWorkEventAdapter {
+    model;
+    request;
+    timeoutMs;
+    id;
+    endpoint;
+    constructor(baseUrl, model, request = fetch, timeoutMs = 120_000) {
+        this.model = model;
+        this.request = request;
+        this.timeoutMs = timeoutMs;
+        const url = new URL(baseUrl);
+        if (url.protocol !== 'http:' ||
+            !['127.0.0.1', '::1', '[::1]', 'localhost'].includes(url.hostname)) {
+            throw new Error('Work-event model endpoint must be loopback HTTP');
+        }
+        this.endpoint = new URL('/v1/chat/completions', url);
+        this.id = `llama.cpp:${model}`;
+    }
+    async generate(input) {
+        const response = await this.request(this.endpoint, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            signal: AbortSignal.timeout(this.timeoutMs),
+            body: JSON.stringify({
+                model: this.model,
+                messages: [
+                    { role: 'system', content: SYSTEM_PROMPT },
+                    { role: 'user', content: input },
+                ],
+                response_format: {
+                    type: 'json_schema',
+                    json_schema: {
+                        name: 'work_event_graph',
+                        strict: true,
+                        schema: WORK_EVENT_GRAPH_JSON_SCHEMA,
+                    },
+                },
+                temperature: 0,
+                max_tokens: 1800,
+            }),
+        });
+        if (!response.ok)
+            throw new Error(`Local model request failed (${response.status})`);
+        const payload = (await response.json());
+        const content = payload?.choices?.[0]?.message?.content;
+        if (typeof content !== 'string' || content.length > 1024 * 1024)
+            throw new Error('Local model response is missing or oversized');
+        const parsed = JSON.parse(content);
+        return { ...parsed, modelId: this.id };
+    }
+}

package/dist/work-item/local-provider.js

@@ -0,0 +1,38 @@
+import { validateProviderCapabilities, } from './provider.js';
+/**
+ * A local review sink. It deliberately never opens a socket or invokes a
+ * system share panel, so preview/delivery can be exercised safely in tests.
+ */
+export class LocalReviewProvider {
+    id = 'local.review';
+    displayName = 'Local review';
+    capabilities = {
+        operations: ['share', 'message', 'issue', 'review'],
+        attachments: true,
+        maxAttachments: 100,
+        requiresApproval: true,
+    };
+    delivered = new Map();
+    validate(draft) {
+        return validateProviderCapabilities(this, draft);
+    }
+    async deliver(draft) {
+        const validation = this.validate(draft);
+        if (!validation.valid)
+            throw new Error(validation.errors.join('; '));
+        // Keep the in-process object available to a local UI/reviewer only.
+        this.delivered.set(draft.id, structuredClone(draft));
+        return {
+            delivery: {
+                providerId: this.id,
+                deliveredAt: Date.now(),
+                external: false,
+                reference: `local-review://${draft.id}`,
+            },
+        };
+    }
+    get(id) {
+        const draft = this.delivered.get(id);
+        return draft ? structuredClone(draft) : null;
+    }
+}

package/dist/work-item/local-work-event-provider.js

@@ -0,0 +1,56 @@
+import { validateFactorizedGraphModelOutput, } from './work-event-inference.js';
+import { assertProductionEligibleModel, } from './work-event-model-manifest.js';
+export class LocalModelOutputError extends Error {
+    reasons;
+    constructor(reasons) {
+        super(`Local work-event model output is invalid: ${reasons.join(', ')}`);
+        this.reasons = reasons;
+    }
+}
+export function serializeEventContextForModel(context) {
+    const messages = context.messages.map((message, index) => JSON.stringify({
+        index,
+        messageId: message.messageId,
+        speaker: message.isSelf ? 'self' : 'other',
+        sentAt: message.sentAt,
+        text: message.text,
+        mediaType: message.mediaType ?? null,
+        mentionsSelf: message.mentionsSelf ?? false,
+    }));
+    const edges = context.edges.map((edge) => JSON.stringify({
+        parentId: edge.parentId,
+        childId: edge.childId,
+        weight: edge.weight,
+        entropy: edge.entropy,
+    }));
+    return [
+        JSON.stringify({
+            schemaVersion: 1,
+            chatId: context.chatId,
+            anchorMessageIds: context.anchorMessageIds,
+            complete: context.complete,
+            boundary: context.boundary,
+        }),
+        ...messages,
+        'EDGES',
+        ...edges,
+    ].join('\n');
+}
+export class LocalFactorizedWorkEventProvider {
+    adapter;
+    id;
+    constructor(adapter, manifest) {
+        this.adapter = adapter;
+        assertProductionEligibleModel(manifest);
+        if (manifest.modelId !== adapter.id)
+            throw new Error('Model manifest does not match the local adapter');
+        this.id = `local:${adapter.id}`;
+    }
+    async infer(context) {
+        const raw = await this.adapter.generate(serializeEventContextForModel(context));
+        const reasons = validateFactorizedGraphModelOutput(raw);
+        if (reasons.length > 0)
+            throw new LocalModelOutputError(reasons);
+        return { ...raw, modelId: this.id };
+    }
+}