@xopcai/xopc 0.0.321 → 0.0.324

package/dist/src/home-intelligence/notification.js

@@ -0,0 +1,20 @@
+import { createHash } from "node:crypto";
+//#region src/home-intelligence/notification.ts
+function buildHomeOpportunityNotification(opportunity, reasons, placement) {
+	const backgroundRefresh = reasons.includes("connector_changed") || reasons.includes("scheduled_refresh");
+	const foregroundRefresh = reasons.includes("home_opened") || reasons.includes("manual_refresh");
+	const hasCrossSourceEvidence = opportunity.evidence.some((item) => item.sourceType === "calendar" || item.sourceType === "mail" || item.sourceType === "communication");
+	if (!backgroundRefresh || foregroundRefresh || placement !== "primary" || opportunity.confidence !== "high" || opportunity.urgency !== "now" || !opportunity.actions.canStart || !hasCrossSourceEvidence) return void 0;
+	const evidenceRevision = opportunity.evidence.map((item) => `${item.sourceType}:${item.sourceRef}:${item.revision}`).sort().join("\n");
+	return {
+		notificationKey: createHash("sha256").update([
+			opportunity.kind,
+			opportunity.projectId ?? "global",
+			evidenceRevision
+		].join("\n")).digest("hex"),
+		opportunityId: opportunity.id,
+		title: opportunity.title
+	};
+}
+//#endregion
+export { buildHomeOpportunityNotification };

package/dist/src/home-intelligence/policy.d.ts

@@ -0,0 +1,16 @@
+import type { HomeModelResult } from './generator.js';
+import type { HomeCapabilityRequirement, HomeCapabilityResolution } from './capability-preflight.js';
+import type { HomeGeneratedResult } from './types.js';
+import type { HomeContextSnapshot } from './snapshot.js';
+import { type HomeAdvicePersonalization } from './strategy.js';
+export declare class HomeAdvicePolicy {
+    private readonly resolveCapabilities;
+    private readonly suppressedKeys;
+    private readonly successfulCounts;
+    private readonly personalization;
+    constructor(resolveCapabilities: (requirements: readonly HomeCapabilityRequirement[], options?: {
+        degradedActionAvailable?: boolean;
+    }) => HomeCapabilityResolution, suppressedKeys?: ReadonlySet<string>, successfulCounts?: ReadonlyMap<string, number>, personalization?: HomeAdvicePersonalization);
+    apply(snapshot: HomeContextSnapshot, model: HomeModelResult, now: number): HomeGeneratedResult;
+    private continuation;
+}

package/dist/src/home-intelligence/policy.js

@@ -0,0 +1,152 @@
+import { homePatternKey } from "./strategy.js";
+import { randomUUID } from "node:crypto";
+//#region src/home-intelligence/policy.ts
+const CONFIDENCE_SCORE = {
+	high: 30,
+	medium: 20,
+	low: 0
+};
+const URGENCY_SCORE = {
+	now: 12,
+	today: 8,
+	this_week: 4
+};
+const RISK_PENALTY = {
+	analysis: 0,
+	external_read: 1,
+	file_write: 4,
+	external_write: 10
+};
+function expiryFor(urgency, now) {
+	if (urgency === "now") return now + 360 * 6e4;
+	if (urgency === "today") return now + 1440 * 6e4;
+	return now + 4320 * 6e4;
+}
+function normalized(value) {
+	return (value ?? "").toLocaleLowerCase().replace(/[\p{P}\p{S}\s]+/gu, "");
+}
+function hasRequiredScenarioEvidence(kind, evidence) {
+	if (kind === "meeting_prep") return evidence.some((item) => item.sourceType === "calendar");
+	if (kind === "commitment_follow_up") return evidence.some((item) => item.sourceType === "mail" || item.sourceType === "communication");
+	return true;
+}
+var HomeAdvicePolicy = class {
+	constructor(resolveCapabilities, suppressedKeys = /* @__PURE__ */ new Set(), successfulCounts = /* @__PURE__ */ new Map(), personalization = { highConfidenceKinds: /* @__PURE__ */ new Set() }) {
+		this.resolveCapabilities = resolveCapabilities;
+		this.suppressedKeys = suppressedKeys;
+		this.successfulCounts = successfulCounts;
+		this.personalization = personalization;
+	}
+	apply(snapshot, model, now) {
+		const evidenceById = new Map(snapshot.evidence.map((item) => [item.id, item]));
+		if (model.state === "quiet") return model;
+		if (model.state === "clarification") {
+			const evidenceIds = [...new Set(model.evidenceIds)].filter((id) => (evidenceById.get(id)?.freshUntil ?? 0) > now);
+			const options = [...new Map(model.options.map((option) => [option.id, option])).values()];
+			if (evidenceIds.length < 2 || options.length < 2) return {
+				state: "quiet",
+				reason: "insufficient_value"
+			};
+			return {
+				state: "clarification",
+				question: {
+					id: randomUUID(),
+					revision: 1,
+					question: model.question,
+					options,
+					evidenceIds
+				},
+				generatedAt: now,
+				expiresAt: now + 1440 * 6e4
+			};
+		}
+		const projectIds = new Set(snapshot.projects.map((project) => project.id));
+		const scored = model.candidates.flatMap((candidate) => {
+			if (candidate.confidence === "low" || candidate.projectId && !projectIds.has(candidate.projectId)) return [];
+			if (candidate.confidence !== "high" && this.personalization.highConfidenceKinds.has(candidate.kind)) return [];
+			if (this.suppressedKeys.has(`${candidate.kind}:${candidate.projectId ?? "global"}`)) return [];
+			if (snapshot.tasks.some((task) => task.projectId === candidate.projectId && (normalized(task.title) === normalized(candidate.title) || task.objective && normalized(task.objective) === normalized(candidate.outcome)))) return [];
+			const evidence = [...new Set(candidate.evidenceIds)].map((id) => evidenceById.get(id)).filter((item) => Boolean(item && item.freshUntil > now));
+			if (!evidence.length || !hasRequiredScenarioEvidence(candidate.kind, evidence)) return [];
+			const capabilities = this.resolveCapabilities(candidate.requiredCapabilities, { degradedActionAvailable: Boolean(candidate.degradedActionPrompt) }).capabilities;
+			const missingRequired = capabilities.some((item) => item.required && item.readiness !== "ready");
+			const canStart = !missingRequired && candidate.risk !== "external_write";
+			const degradedStartAvailable = missingRequired && Boolean(candidate.degradedActionPrompt) && candidate.risk !== "external_write";
+			return [{
+				opportunity: {
+					id: randomUUID(),
+					revision: 1,
+					kind: candidate.kind,
+					projectId: candidate.projectId,
+					title: candidate.title,
+					outcome: candidate.outcome,
+					rationale: candidate.rationale,
+					evidence,
+					confidence: candidate.confidence,
+					urgency: candidate.urgency,
+					estimatedMinutes: candidate.estimatedMinutes,
+					risk: candidate.risk,
+					proposedSteps: candidate.proposedSteps,
+					capabilities,
+					verification: candidate.verification,
+					actionPrompt: candidate.actionPrompt,
+					degradedActionPrompt: candidate.degradedActionPrompt,
+					...this.continuation(candidate, snapshot.locale),
+					actions: {
+						canStart,
+						canDiscuss: true,
+						degradedStartAvailable
+					},
+					generatedAt: now,
+					expiresAt: expiryFor(candidate.urgency, now)
+				},
+				score: CONFIDENCE_SCORE[candidate.confidence] + URGENCY_SCORE[candidate.urgency] - RISK_PENALTY[candidate.risk] - (missingRequired ? 12 : 0) + Math.min(evidence.length, 3)
+			}];
+		});
+		const seen = /* @__PURE__ */ new Set();
+		const ranked = scored.sort((left, right) => right.score - left.score || left.opportunity.title.localeCompare(right.opportunity.title)).filter(({ opportunity }) => {
+			const key = `${opportunity.kind}:${opportunity.projectId ?? "global"}:${normalized(opportunity.outcome)}`;
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		}).slice(0, 3);
+		if (!ranked.length) return {
+			state: "quiet",
+			reason: "insufficient_value"
+		};
+		const primary = ranked[0];
+		return {
+			state: "ready",
+			opportunities: ranked.map((item) => item.opportunity),
+			placement: primary.score >= 38 && primary.opportunity.actions.canStart ? "primary" : "compact"
+		};
+	}
+	continuation(candidate, locale) {
+		if (candidate.kind !== "automation_candidate") return {};
+		const successCount = this.successfulCounts.get(homePatternKey(candidate.projectId, candidate.outcome)) ?? 0;
+		if (successCount >= 2) {
+			const outcome = candidate.outcome.slice(0, 140);
+			const approach = candidate.actionPrompt.slice(0, 140);
+			const prompt = locale === "zh" ? `把这项已经稳定成功的工作设计成可复核的 Automation 草稿：${outcome}\n执行方式：${approach}\n请先确认触发条件、频率、范围和外部动作边界，不要直接发布。` : `Design a reviewable Automation draft for this repeatedly successful work: ${outcome}\nExecution approach: ${approach}\nFirst confirm the trigger, schedule, scope, and external-action boundaries. Do not publish it automatically.`;
+			const params = new URLSearchParams({
+				draft: prompt,
+				autogenerate: "1"
+			});
+			if (candidate.projectId) params.set("projectId", candidate.projectId);
+			return { continuation: {
+				kind: "automation",
+				reason: "repeated_success",
+				href: `/automations?${params.toString()}`,
+				successCount
+			} };
+		}
+		if (successCount === 1) return { continuation: {
+			kind: "scene",
+			reason: "prior_success",
+			href: "/scenes"
+		} };
+		return {};
+	}
+};
+//#endregion
+export { HomeAdvicePolicy };

package/dist/src/home-intelligence/repository.d.ts

@@ -0,0 +1,81 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { type HomeAdvisor, type HomeAdviceMetrics, type HomeOpportunity, type HomeOpportunityHistoryItem } from '@xopcai/gateway-contract';
+import type { HomeGeneratedResult } from './types.js';
+import { type HomeAdvicePersonalization, type HomeSuccessfulPattern } from './strategy.js';
+export interface HomePrincipal {
+    ownerId: string;
+    workspaceId: string;
+}
+export type HomeGenerationReason = 'home_opened' | 'manual_refresh' | 'project_changed' | 'task_changed' | 'conversation_changed' | 'connector_changed' | 'scheduled_refresh';
+export interface HomeGenerationClaim extends HomePrincipal {
+    generationId: string;
+    leaseOwner: string;
+    leaseEpoch: number;
+    attempt: number;
+    reasons: HomeGenerationReason[];
+}
+export interface HomeGenerationCompletion {
+    result: HomeGeneratedResult;
+    snapshotHash: string;
+    evidenceIds: string[];
+    modelRef?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    estimatedCostUsd?: number;
+    outcomeReason?: string;
+    completedAt: number;
+}
+export type HomeFeedbackKind = 'started' | 'discussed' | 'already_done' | 'irrelevant' | 'too_early' | 'source_incorrect' | 'less_like_this' | 'snoozed';
+export interface HomeOpportunityFeedbackInput {
+    feedbackId?: string;
+    idempotencyKey: string;
+    kind: HomeFeedbackKind;
+    expectedRevision: number;
+    createdAt: number;
+    reasonCode?: string;
+    note?: string;
+    scope?: Record<string, unknown>;
+    snoozedUntil?: number;
+    resolution?: {
+        kind: 'session' | 'task' | 'scene';
+        ref: string;
+    };
+}
+export declare class HomeIntelligenceRepository {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    enqueue(principal: HomePrincipal, input: {
+        idempotencyKey: string;
+        reasons: HomeGenerationReason[];
+        requestedAt: number;
+    }): {
+        generationId: string;
+        created: boolean;
+    };
+    claimNext(principal: HomePrincipal, workerId: string, now: number, leaseMs?: number): HomeGenerationClaim | undefined;
+    complete(claim: HomeGenerationClaim, completion: HomeGenerationCompletion): {
+        dirty: boolean;
+    };
+    fail(claim: HomeGenerationClaim, now: number, errorCode: string, retryAt?: number): void;
+    getLatestSnapshotHash(principal: HomePrincipal): string | undefined;
+    countModelGenerationAttemptsSince(principal: HomePrincipal, since: number, currentGenerationId: string): number;
+    listSuppressionKeys(principal: HomePrincipal): Set<string>;
+    getSuccessfulPatterns(principal: HomePrincipal): HomeSuccessfulPattern[];
+    getPersonalization(principal: HomePrincipal, now: number): HomeAdvicePersonalization;
+    getMetrics(principal: HomePrincipal, since: number, until: number): HomeAdviceMetrics;
+    invalidateOpportunitiesByEvidenceSources(principal: HomePrincipal, sourceTypes: ReadonlySet<HomeOpportunity['evidence'][number]['sourceType']>, now: number): number;
+    getAdvisor(principal: HomePrincipal, now: number): HomeAdvisor;
+    getOpportunity(principal: HomePrincipal, opportunityId: string, now: number): HomeOpportunity | undefined;
+    getOpportunitySnapshot(principal: HomePrincipal, opportunityId: string): HomeOpportunity | undefined;
+    listHistory(principal: HomePrincipal): HomeOpportunityHistoryItem[];
+    isFeedbackRecorded(opportunityId: string, idempotencyKey: string): boolean;
+    recordFeedback(principal: HomePrincipal, opportunityId: string, input: HomeOpportunityFeedbackInput): HomeOpportunity | undefined;
+    undoFeedback(principal: HomePrincipal, opportunityId: string, idempotencyKey: string, now: number): HomeOpportunity;
+    maintain(now: number): {
+        expired: number;
+        awakened: number;
+    };
+    private requireClaim;
+    private feedbackTransition;
+    private opportunityDedupeKey;
+}