@rikaidev/yomi 0.5.0 → 0.6.1

package/dist/work-item/registry.js

@@ -0,0 +1,19 @@
+export class WorkItemProviderRegistry {
+    providers = new Map();
+    register(provider) {
+        if (this.providers.has(provider.id)) {
+            throw new Error(`Work item provider already registered: ${provider.id}`);
+        }
+        this.providers.set(provider.id, provider);
+        return this;
+    }
+    resolve(id) {
+        const provider = this.providers.get(id);
+        if (!provider)
+            throw new Error(`Unknown work item provider: ${id}`);
+        return provider;
+    }
+    list() {
+        return [...this.providers.values()];
+    }
+}

package/dist/work-item/service.js

@@ -0,0 +1,85 @@
+import { randomUUID } from 'node:crypto';
+import { validateProviderCapabilities, } from './provider.js';
+import { createWorkItemDraft, transitionWorkItem, } from './types.js';
+export class WorkItemService {
+    store;
+    registry;
+    constructor(store, registry) {
+        this.store = store;
+        this.registry = registry;
+    }
+    async create(adapter, input, options = {}) {
+        const normalized = await adapter.normalize(input);
+        const now = options.now ?? Date.now();
+        const draft = createWorkItemDraft({
+            id: options.id ?? `work-${now}-${randomUUID()}`,
+            createdAt: now,
+            source: normalized.source,
+            sources: normalized.sources,
+            evidence: normalized.evidence,
+            summary: options.summary ?? null,
+            action: options.action ?? 'review',
+            destination: options.destination ?? null,
+            assignee: options.assignee ?? null,
+            labels: options.labels ?? [],
+        });
+        await this.store.save(draft);
+        return draft;
+    }
+    async transition(id, event) {
+        const current = await this.store.get(id);
+        if (!current || !('evidence' in current))
+            throw new Error(`Unknown work item: ${id}`);
+        const next = transitionWorkItem(current, event);
+        await this.store.save(next);
+        return next;
+    }
+    async deliver(id, provider) {
+        const current = await this.store.get(id);
+        if (!current || !('evidence' in current))
+            throw new Error(`Unknown work item: ${id}`);
+        if (current.destination && current.destination !== provider.id) {
+            throw new Error(`Work item destination ${current.destination} does not match provider ${provider.id}`);
+        }
+        const candidate = current.destination
+            ? current
+            : { ...current, destination: provider.id };
+        const capabilityValidation = validateProviderCapabilities(provider, candidate);
+        const providerValidation = provider.validate(candidate);
+        const errors = [
+            ...capabilityValidation.errors,
+            ...providerValidation.errors,
+        ];
+        if (errors.length > 0)
+            throw new Error(errors.join('; '));
+        const sending = transitionWorkItem(candidate, { type: 'send' });
+        await this.store.save(sending);
+        try {
+            const result = await provider.deliver(sending);
+            const delivered = transitionWorkItem(sending, {
+                type: 'deliver',
+                delivery: result.delivery,
+            });
+            await this.store.save(delivered);
+            return delivered;
+        }
+        catch (error) {
+            const failed = transitionWorkItem(sending, {
+                type: 'fail',
+                failure: {
+                    code: 'provider_delivery_failed',
+                    message: error instanceof Error ? error.message : String(error),
+                    at: Date.now(),
+                    retryable: true,
+                },
+            });
+            await this.store.save(failed);
+            throw error;
+        }
+    }
+    async deliverByProviderId(id, providerId) {
+        if (!this.registry)
+            throw new Error('Work item provider registry is not configured');
+        return this.deliver(id, this.registry.resolve(providerId));
+    }
+}

package/dist/work-item/store.js

@@ -0,0 +1,97 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { yomiDataPath } from '../util/data-dir.js';
+function digest(value) {
+    if (value === null)
+        return null;
+    return createHash('sha256').update(value).digest('hex');
+}
+export function toPersistedWorkItem(draft) {
+    const primarySource = draft.source ?? draft.sources[0];
+    if (!primarySource)
+        throw new Error('Work item has no source to persist');
+    return {
+        id: draft.id,
+        createdAt: draft.createdAt,
+        updatedAt: draft.updatedAt,
+        source: {
+            adapter: primarySource.adapter,
+            platform: primarySource.platform,
+            conversationIdHash: digest(primarySource.conversationId),
+            messageIdHashes: primarySource.messageIds.map((messageId) => digest(messageId)),
+            latestMessageAt: primarySource.latestMessageAt,
+        },
+        evidence: draft.evidence.map((evidence) => ({
+            sourceMessageIdHash: digest(evidence.sourceMessageId),
+            senderIdHash: evidence.senderId === null ? null : digest(evidence.senderId),
+            senderNameHash: evidence.senderName === null ? null : digest(evidence.senderName),
+            sentAt: evidence.sentAt,
+            textSha256: digest(evidence.text),
+            attachments: evidence.attachments.map((attachment) => ({
+                idHash: digest(attachment.id),
+                fileNameSha256: digest(attachment.fileName),
+                mimeType: attachment.mimeType,
+                byteLength: attachment.byteLength,
+                sha256: attachment.sha256,
+            })),
+        })),
+        summarySha256: digest(draft.summary),
+        action: draft.action,
+        destination: draft.destination,
+        assignee: draft.assignee,
+        labels: [...draft.labels],
+        status: draft.status,
+        failure: draft.failure,
+        delivery: draft.delivery,
+    };
+}
+export class InMemoryWorkItemStore {
+    drafts = new Map();
+    async save(draft) {
+        this.drafts.set(draft.id, structuredClone(draft));
+    }
+    async get(id) {
+        const draft = this.drafts.get(id);
+        return draft ? structuredClone(draft) : null;
+    }
+    async list() {
+        return [...this.drafts.values()].map((draft) => structuredClone(draft));
+    }
+}
+/** Metadata-only persistence. It intentionally cannot be used to deliver a draft. */
+export class FileWorkItemStore {
+    path;
+    maxItems;
+    constructor(path = yomiDataPath('work-items.json'), maxItems = 200) {
+        this.path = path;
+        this.maxItems = Math.max(1, maxItems);
+    }
+    async save(draft) {
+        const entries = await this.read();
+        const persisted = toPersistedWorkItem(draft);
+        const next = [
+            persisted,
+            ...entries.filter((entry) => entry.id !== draft.id),
+        ].slice(0, this.maxItems);
+        await mkdir(dirname(this.path), { recursive: true });
+        const temporary = `${this.path}.tmp-${process.pid}`;
+        await writeFile(temporary, JSON.stringify(next), { mode: 0o600 });
+        await rename(temporary, this.path);
+    }
+    async get(id) {
+        return (await this.read()).find((entry) => entry.id === id) ?? null;
+    }
+    async list() {
+        return this.read();
+    }
+    async read() {
+        try {
+            const value = JSON.parse(await readFile(this.path, 'utf8'));
+            return Array.isArray(value) ? value : [];
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/work-item/types.js

@@ -0,0 +1,79 @@
+/**
+ * Destination-agnostic work item domain.
+ *
+ * Message text and attachment bytes are intentionally kept in memory only.
+ * The persistence projection (see store.ts) contains metadata and digests,
+ * never decrypted LINE content.
+ */
+const TRANSITIONS = {
+    draft: ['preview'],
+    preview: ['approved', 'draft'],
+    approved: ['sending', 'draft'],
+    sending: ['delivered', 'failed'],
+    delivered: [],
+    failed: ['approved', 'draft'],
+};
+export function canTransition(from, to) {
+    return TRANSITIONS[from].includes(to);
+}
+export function transitionWorkItem(draft, event, now = Date.now()) {
+    const target = event.type === 'preview'
+        ? 'preview'
+        : event.type === 'approve'
+            ? 'approved'
+            : event.type === 'send'
+                ? 'sending'
+                : event.type === 'deliver'
+                    ? 'delivered'
+                    : event.type === 'fail'
+                        ? 'failed'
+                        : 'approved';
+    if (!canTransition(draft.status, target)) {
+        throw new Error(`Invalid work item transition: ${draft.status} → ${target}`);
+    }
+    if (draft.status === 'failed' && event.type !== 'retry') {
+        throw new Error('Failed work items must use retry');
+    }
+    if (event.type === 'retry' && !draft.failure?.retryable) {
+        throw new Error('Work item failure is not retryable');
+    }
+    const updatedAt = event.at ?? now;
+    return {
+        ...draft,
+        status: target,
+        updatedAt,
+        failure: event.type === 'fail' || event.type === 'retry'
+            ? event.type === 'fail'
+                ? event.failure
+                : null
+            : null,
+        delivery: event.type === 'deliver' ? event.delivery : draft.delivery,
+    };
+}
+export function createWorkItemDraft(input) {
+    const sources = input.sources?.length
+        ? input.sources
+        : input.evidence
+            .map((evidence) => evidence.source ?? input.source)
+            .filter((source) => Boolean(source));
+    return {
+        ...input,
+        sources,
+        source: input.source ?? sources[0],
+        updatedAt: input.updatedAt ?? input.createdAt,
+        status: 'draft',
+        failure: null,
+        delivery: null,
+    };
+}
+/** Upgrade a draft received from a pre-collection bridge. */
+export function normalizeWorkItemDraft(draft) {
+    const sources = draft.sources?.length
+        ? draft.sources
+        : draft.evidence
+            .map((evidence) => evidence.source ?? draft.source)
+            .filter((source) => Boolean(source));
+    if (sources.length === 0)
+        throw new Error('Work item has no valid evidence source');
+    return { ...draft, sources, source: draft.source ?? sources[0] };
+}

package/dist/work-item/work-event-graph-engine.js

@@ -0,0 +1,63 @@
+import { reviseWorkEvent, } from './work-event.js';
+import { projectFactorizedGraphInference, } from './work-event-inference.js';
+import { matchWorkEventRevisions } from './work-event-matcher.js';
+export class WorkEventGraphEngine {
+    provider;
+    sink;
+    latest = new Map();
+    constructor(provider, sink, initial = []) {
+        this.provider = provider;
+        this.sink = sink;
+        for (const revision of initial)
+            this.latest.set(revision.eventId, revision);
+    }
+    async observe(context, thresholds, inferredAt = Date.now()) {
+        let output;
+        try {
+            output = await this.provider.infer(context);
+        }
+        catch {
+            return {
+                projection: {
+                    dialogue: [],
+                    candidates: [
+                        {
+                            candidateKey: '',
+                            result: {
+                                kind: 'abstain',
+                                reasons: ['provider_inference_failed'],
+                                modelId: this.provider.id,
+                            },
+                        },
+                    ],
+                    modelId: this.provider.id,
+                },
+                revisions: [],
+            };
+        }
+        const projection = projectFactorizedGraphInference(context, output, thresholds, inferredAt);
+        const incoming = projection.candidates.flatMap((candidate) => candidate.result.kind === 'inference' ? [candidate.result.inference] : []);
+        const previous = [...this.latest.values()].filter((revision) => revision.chatId === context.chatId);
+        const matches = matchWorkEventRevisions(previous, incoming);
+        const previousByIncoming = new Map(matches.map((match) => [
+            match.incomingIndex,
+            previous[match.previousIndex],
+        ]));
+        const revisions = incoming.map((inference, index) => {
+            const prior = previousByIncoming.get(index) ?? null;
+            const stableInference = prior
+                ? { ...inference, eventId: prior.eventId }
+                : inference;
+            return reviseWorkEvent(prior, stableInference);
+        });
+        if (revisions.length > 0) {
+            await this.sink.appendMany(revisions);
+            for (const revision of revisions)
+                this.latest.set(revision.eventId, revision);
+        }
+        return { projection, revisions };
+    }
+    current() {
+        return [...this.latest.values()].sort((left, right) => right.inferredAt - left.inferredAt);
+    }
+}

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

@@ -0,0 +1,267 @@
+const DIALOGUE_ACTS = new Set([
+    'inform',
+    'ask',
+    'answer',
+    'directive',
+    'commit',
+    'delegate',
+    'acknowledge',
+    'deliver',
+    'accept',
+    'reject',
+    'cancel',
+]);
+const OWNERSHIP_STATES = new Set([
+    'unassigned',
+    'owned',
+    'delegated',
+    'unknown',
+]);
+const PARTICIPANT_KINDS = new Set([
+    'self',
+    'conversation_member',
+    'external_party',
+    'unknown',
+]);
+const DEPENDENCY_STATES = 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',
+]);
+const DEFAULT_THRESHOLDS = {
+    createsWork: 0.82,
+    action: 0.78,
+    ownership: 0.8,
+    dependency: 0.76,
+    lifecycle: 0.82,
+    completion: 0.86,
+};
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function validConfidence(value) {
+    return (typeof value === 'number' &&
+        Number.isFinite(value) &&
+        value >= 0 &&
+        value <= 1);
+}
+function validEvidenceArray(value) {
+    return (Array.isArray(value) &&
+        value.every((item) => typeof item === 'string' && item.length > 0));
+}
+/** Runtime boundary for untrusted JSON emitted by a local model. */
+export function validateFactorizedGraphModelOutput(value) {
+    const errors = [];
+    if (!isRecord(value))
+        return ['model_output_not_object'];
+    if (typeof value.modelId !== 'string' || !value.modelId)
+        errors.push('model_id_invalid');
+    if (!Array.isArray(value.dialogue))
+        errors.push('dialogue_invalid');
+    else
+        for (const item of value.dialogue) {
+            if (!isRecord(item) ||
+                typeof item.messageId !== 'string' ||
+                !Array.isArray(item.acts) ||
+                item.acts.some((act) => !DIALOGUE_ACTS.has(act)) ||
+                !validConfidence(item.confidence))
+                errors.push('dialogue_item_invalid');
+        }
+    if (!Array.isArray(value.candidates))
+        errors.push('candidates_invalid');
+    else
+        for (const candidate of value.candidates) {
+            if (!isRecord(candidate) ||
+                typeof candidate.candidateKey !== 'string' ||
+                !candidate.candidateKey) {
+                errors.push('candidate_key_invalid');
+                continue;
+            }
+            for (const name of [
+                'createsWork',
+                'ownership',
+                'dependency',
+                'lifecycle',
+                'completion',
+            ]) {
+                const field = candidate[name];
+                if (!isRecord(field) ||
+                    !validConfidence(field.confidence) ||
+                    !validEvidenceArray(field.evidenceMessageIds))
+                    errors.push(`${name}_field_invalid`);
+            }
+            if (!isRecord(candidate.createsWork) ||
+                typeof candidate.createsWork.value !== 'boolean')
+                errors.push('creates_work_value_invalid');
+            if (candidate.action !== null) {
+                if (!isRecord(candidate.action) ||
+                    typeof candidate.action.predicate !== 'string' ||
+                    !candidate.action.predicate ||
+                    !validEvidenceArray(candidate.action.sourceMessageIds) ||
+                    candidate.action.sourceMessageIds.length === 0 ||
+                    !validConfidence(candidate.action.confidence))
+                    errors.push('action_invalid');
+            }
+            const ownership = candidate.ownership?.value;
+            if (!isRecord(ownership) ||
+                !OWNERSHIP_STATES.has(ownership.state) ||
+                !Array.isArray(ownership.owners) ||
+                ownership.owners.some((owner) => !isRecord(owner) || !PARTICIPANT_KINDS.has(owner.kind)))
+                errors.push('ownership_value_invalid');
+            const dependency = candidate.dependency?.value;
+            if (!isRecord(dependency) || !DEPENDENCY_STATES.has(dependency.state))
+                errors.push('dependency_value_invalid');
+            if (!isRecord(candidate.lifecycle) ||
+                !LIFECYCLES.has(candidate.lifecycle.value))
+                errors.push('lifecycle_value_invalid');
+            const completion = candidate.completion?.value;
+            if (!isRecord(completion) ||
+                ['delivered', 'accepted', 'cancelled'].some((key) => typeof completion[key] !== 'boolean'))
+                errors.push('completion_value_invalid');
+        }
+    return [...new Set(errors)];
+}
+function validEvidence(ids, available) {
+    return ids.length === 0 || ids.every((id) => available.has(id));
+}
+/** Validate, calibrate and project model output. It never converts uncertainty into no-work. */
+export function projectFactorizedInference(context, output, thresholds = DEFAULT_THRESHOLDS, inferredAt = Date.now()) {
+    const reasons = [];
+    const available = new Set(context.messages.map((message) => message.messageId));
+    if (!context.complete)
+        reasons.push(`context_${context.boundary}`);
+    if (output.dialogue.some((item) => !available.has(item.messageId)))
+        reasons.push('dialogue_evidence_outside_context');
+    if (!validEvidence(output.createsWork.evidenceMessageIds, available))
+        reasons.push('work_evidence_outside_context');
+    if (output.createsWork.confidence < thresholds.createsWork)
+        reasons.push('work_confidence_low');
+    if (output.createsWork.value && !output.action)
+        reasons.push('work_action_missing');
+    if (output.action) {
+        if (output.action.sourceMessageIds.length === 0)
+            reasons.push('action_source_missing');
+        if (!validEvidence(output.action.sourceMessageIds, available))
+            reasons.push('action_source_outside_context');
+        if (output.action.confidence < thresholds.action)
+            reasons.push('action_confidence_low');
+    }
+    for (const [name, field, threshold] of [
+        ['ownership', output.ownership, thresholds.ownership],
+        ['dependency', output.dependency, thresholds.dependency],
+        ['lifecycle', output.lifecycle, thresholds.lifecycle],
+        ['completion', output.completion, thresholds.completion],
+    ]) {
+        if (field.confidence < threshold)
+            reasons.push(`${name}_confidence_low`);
+        if (!validEvidence(field.evidenceMessageIds, available))
+            reasons.push(`${name}_evidence_outside_context`);
+    }
+    if (output.completion.value.accepted && !output.completion.value.delivered)
+        reasons.push('acceptance_without_delivery');
+    if (output.lifecycle.value === 'accepted' &&
+        !output.completion.value.accepted)
+        reasons.push('accepted_lifecycle_without_evidence');
+    if (output.lifecycle.value === 'cancelled' &&
+        !output.completion.value.cancelled)
+        reasons.push('cancelled_lifecycle_without_evidence');
+    if (reasons.length > 0)
+        return { kind: 'abstain', reasons, modelId: output.modelId };
+    return {
+        kind: 'inference',
+        inference: {
+            eventId: context.anchorMessageIds.slice().sort().join(':'),
+            chatId: context.chatId,
+            evidence: context.messages.map((message) => ({
+                messageId: message.messageId,
+                chatId: message.chatId,
+                sentAt: message.sentAt,
+                speaker: message.isSelf ? 'self' : 'other',
+            })),
+            dialogue: output.dialogue,
+            createsWork: output.createsWork.value,
+            workConfidence: output.createsWork.confidence,
+            action: output.action
+                ? {
+                    predicate: output.action.predicate,
+                    object: output.action.object,
+                    expectedOutcome: output.action.expectedOutcome,
+                    dueAt: output.action.dueAt,
+                    confidence: output.action.confidence,
+                    evidenceMessageIds: output.action.sourceMessageIds,
+                }
+                : null,
+            ownership: {
+                ...output.ownership.value,
+                confidence: output.ownership.confidence,
+                evidenceMessageIds: output.ownership.evidenceMessageIds,
+            },
+            dependency: {
+                ...output.dependency.value,
+                confidence: output.dependency.confidence,
+                evidenceMessageIds: output.dependency.evidenceMessageIds,
+            },
+            lifecycle: output.lifecycle.value,
+            completion: {
+                ...output.completion.value,
+                confidence: output.completion.confidence,
+                evidenceMessageIds: output.completion.evidenceMessageIds,
+            },
+            sourceModel: output.modelId,
+            inferredAt,
+        },
+    };
+}
+/** Project every hypothesis independently; one utterance may support several events. */
+export function projectFactorizedGraphInference(context, output, thresholds = DEFAULT_THRESHOLDS, inferredAt = Date.now()) {
+    const validationErrors = validateFactorizedGraphModelOutput(output);
+    if (validationErrors.length > 0) {
+        return {
+            dialogue: [],
+            candidates: [
+                {
+                    candidateKey: '',
+                    result: {
+                        kind: 'abstain',
+                        reasons: validationErrors.map((error) => `model_output_${error}`),
+                        modelId: typeof output?.modelId === 'string' ? output.modelId : 'unknown',
+                    },
+                },
+            ],
+            modelId: typeof output?.modelId === 'string' ? output.modelId : 'unknown',
+        };
+    }
+    const keys = new Set();
+    const candidates = output.candidates.map((candidate) => {
+        if (!candidate.candidateKey || keys.has(candidate.candidateKey)) {
+            return {
+                candidateKey: candidate.candidateKey,
+                result: {
+                    kind: 'abstain',
+                    reasons: ['candidate_key_invalid'],
+                    modelId: output.modelId,
+                },
+            };
+        }
+        keys.add(candidate.candidateKey);
+        const result = projectFactorizedInference(context, { ...candidate, dialogue: output.dialogue, modelId: output.modelId }, thresholds, inferredAt);
+        if (result.kind === 'inference') {
+            result.inference.eventId = `${context.anchorMessageIds.slice().sort().join(':')}:${candidate.candidateKey}`;
+        }
+        return { candidateKey: candidate.candidateKey, result };
+    });
+    return { dialogue: output.dialogue, candidates, modelId: output.modelId };
+}