@xopcai/xopc 0.0.188 → 0.0.190

package/dist/src/user-context/projection.js

@@ -1,262 +0,0 @@
-import { effectiveMemoryStatus, resolveMemoryStability } from "../agent/memory/lifecycle.js";
-import { classifyMemoryContextOrigin } from "../agent/memory/source-origin.js";
-//#region src/user-context/projection.ts
-const ALWAYS_PERSONAL_KINDS = new Set([
-	"user_profile",
-	"preference",
-	"boundary",
-	"relationship",
-	"commitment",
-	"routine",
-	"personal_logistics",
-	"current_state",
-	"tool_preference",
-	"long_term_goal"
-]);
-const CONTEXTUAL_USER_KINDS = new Set([
-	"project_context",
-	"open_question",
-	"milestone",
-	"derived_insight",
-	"task_lesson"
-]);
-const USER_CONTEXT_MEMORY_KINDS = [...ALWAYS_PERSONAL_KINDS, ...CONTEXTUAL_USER_KINDS];
-function isUserContextRecord(record) {
-	if (ALWAYS_PERSONAL_KINDS.has(record.kind)) return true;
-	return CONTEXTUAL_USER_KINDS.has(record.kind) && record.tags?.includes("user-understanding") === true;
-}
-function isUserContextMemoryKind(value) {
-	return typeof value === "string" && (ALWAYS_PERSONAL_KINDS.has(value) || CONTEXTUAL_USER_KINDS.has(value));
-}
-function facetForMemoryKind(kind) {
-	if (kind === "user_profile" || kind === "personal_logistics") return "basics";
-	if (kind === "preference" || kind === "routine" || kind === "tool_preference" || kind === "task_lesson") return "collaboration";
-	if (kind === "boundary") return "boundaries";
-	if (kind === "relationship") return "people";
-	if (kind === "current_state" || kind === "open_question") return "current";
-	return "priorities";
-}
-function originForMemoryRecord(record) {
-	const origin = classifyMemoryContextOrigin(record);
-	return origin === "told_by_user" ? "told_by_you" : origin;
-}
-function connectedEvidenceBasis(sourceText) {
-	if (!sourceText) return void 0;
-	try {
-		const value = JSON.parse(sourceText);
-		const eventCount = Number(value.eventCount);
-		const activeDays = Number(value.activeDays);
-		const windowDays = Number(value.windowDays);
-		if (![
-			eventCount,
-			activeDays,
-			windowDays
-		].every((item) => Number.isInteger(item) && item > 0)) return void 0;
-		return {
-			eventCount,
-			activeDays,
-			windowDays
-		};
-	} catch {
-		return;
-	}
-}
-function projectUserContextRecord(record) {
-	const lifecycle = resolveMemoryStability(record);
-	const latestEvidenceAt = record.evidence?.map((evidence) => evidence.observedAt).filter((value) => Boolean(value)).sort().at(-1);
-	const evidenceBasis = record.evidence?.map((evidence) => connectedEvidenceBasis(evidence.sourceText)).filter((value) => Boolean(value)).at(-1);
-	return {
-		id: record.id,
-		statement: record.content,
-		facet: facetForMemoryKind(record.kind),
-		kind: record.kind,
-		status: effectiveMemoryStatus(record),
-		origin: originForMemoryRecord(record),
-		sourceName: record.source.provider ?? "local",
-		scope: record.scope.sessionKey ? {
-			type: "session",
-			id: record.scope.sessionKey
-		} : record.scope.projectId ? {
-			type: "project",
-			id: record.scope.projectId
-		} : record.scope.workspaceId ? {
-			type: "workspace",
-			id: record.scope.workspaceId
-		} : { type: "global" },
-		updatedAt: record.updatedAt,
-		sensitivity: record.sensitivity ?? "normal",
-		explicitness: record.explicitness,
-		durability: record.durability,
-		disclosurePolicy: record.disclosurePolicy,
-		stability: lifecycle.band,
-		stabilityScore: lifecycle.score,
-		confidence: record.confidence,
-		reviewAt: lifecycle.reviewAt,
-		reviewDue: lifecycle.reviewDue,
-		evidenceCount: record.evidence?.length ?? 0,
-		evidenceBasis,
-		sourcePath: record.source.path,
-		latestEvidenceAt,
-		validFrom: record.validFrom,
-		validTo: record.validTo,
-		expiresAt: record.expiresAt
-	};
-}
-function isPersonalContextConnector(definition) {
-	return definition.capabilities.includes("context") || definition.capabilities.includes("memory_source");
-}
-function recordsDerivedFromPersonalContextSource(records, sourceInstanceId) {
-	return records.filter((record) => record.source.sourceInstanceId === sourceInstanceId && isUserContextRecord(record));
-}
-function connectionIdentityKey(connection) {
-	if (connection.accountId) return `account:${connection.accountId}`;
-	const email = typeof connection.identity.email === "string" ? connection.identity.email.trim().toLocaleLowerCase() : "";
-	if (email) return `email:${email}`;
-	const username = typeof connection.identity.username === "string" ? connection.identity.username.trim().toLocaleLowerCase() : "";
-	if (username) return `username:${username}`;
-	return `connection:${connection.id}`;
-}
-function selectAccountConnections(connections) {
-	const byIdentity = /* @__PURE__ */ new Map();
-	for (const connection of connections) {
-		const key = connectionIdentityKey(connection);
-		const current = byIdentity.get(key);
-		if (!current) {
-			byIdentity.set(key, connection);
-			continue;
-		}
-		const currentRank = current.status === "active" ? 1 : 0;
-		const candidateRank = connection.status === "active" ? 1 : 0;
-		if (candidateRank > currentRank || candidateRank === currentRank && connection.updatedAt.localeCompare(current.updatedAt) > 0) byIdentity.set(key, connection);
-	}
-	return [...byIdentity.values()];
-}
-function projectPersonalContextSources(definitions, instances, knowledge = {}) {
-	const instanceByConnector = /* @__PURE__ */ new Map();
-	for (const instance of instances) {
-		const current = instanceByConnector.get(instance.connectorId) ?? [];
-		current.push(instance);
-		instanceByConnector.set(instance.connectorId, current);
-	}
-	return definitions.filter(isPersonalContextConnector).flatMap((definition) => {
-		const connected = instanceByConnector.get(definition.id) ?? [];
-		const candidateAccounts = (knowledge.connections ?? []).filter((connection) => connection.provider === "composio" && connection.connectorId === definition.id && connection.status !== "revoked");
-		const hasActiveAccount = candidateAccounts.some((connection) => connection.status === "active");
-		const accounts = selectAccountConnections(candidateAccounts.filter((connection) => !hasActiveAccount || ![
-			"pending",
-			"unknown",
-			"disabled"
-		].includes(connection.status))).sort((left, right) => {
-			return (left.connectedAt ?? left.createdAt).localeCompare(right.connectedAt ?? right.createdAt) || left.id.localeCompare(right.id);
-		});
-		return (accounts.length > 0 ? accounts.map((connection, index) => ({
-			instanceId: connection.accountId,
-			sourceInstanceId: connection.accountId ? `composio:${definition.id}:${connection.accountId}` : void 0,
-			accountLabel: connection.alias ?? (typeof connection.identity.email === "string" ? connection.identity.email : void 0) ?? (typeof connection.identity.username === "string" ? connection.identity.username : void 0),
-			accountOrdinal: index + 1,
-			accountCount: accounts.length,
-			enabled: connection.status === "active",
-			status: connection.status,
-			lastConnectedAt: connection.connectedAt,
-			instances: connected
-		})) : connected.length > 0 ? connected.map((instance) => ({
-			instanceId: instance.instanceId,
-			sourceInstanceId: instance.instanceId,
-			accountLabel: void 0,
-			accountOrdinal: void 0,
-			accountCount: void 0,
-			enabled: instance.enabled,
-			status: instance.status,
-			lastConnectedAt: instance.lastConnectedAt,
-			instances: [instance]
-		})) : [{
-			instanceId: void 0,
-			sourceInstanceId: void 0,
-			accountLabel: void 0,
-			accountOrdinal: void 0,
-			accountCount: void 0,
-			enabled: false,
-			status: "not_installed",
-			lastConnectedAt: void 0,
-			instances: []
-		}]).map((row) => {
-			const sourceItems = row.sourceInstanceId ? (knowledge.sourceItems ?? []).filter((item) => item.sourceInstanceId === row.sourceInstanceId) : [];
-			const claimStats = row.sourceInstanceId ? knowledge.claimStatsBySource?.[row.sourceInstanceId] : void 0;
-			const latestSync = (knowledge.syncRuns ?? []).filter((run) => run.sourceInstanceId === row.sourceInstanceId).sort((left, right) => Date.parse(right.startedAt) - Date.parse(left.startedAt))[0];
-			const learningJobs = (knowledge.learningJobs ?? []).filter((job) => job.sourceInstanceId === row.sourceInstanceId).sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt));
-			const now = Date.now();
-			const nextScheduledLearning = learningJobs.filter((job) => job.status === "queued" && job.nextRunAt && Date.parse(job.nextRunAt) > now).sort((left, right) => Date.parse(left.nextRunAt) - Date.parse(right.nextRunAt))[0];
-			const latestLearning = learningJobs.find((job) => job.status !== "queued" || !job.nextRunAt || Date.parse(job.nextRunAt) <= now) ?? learningJobs[0];
-			const latestHealth = row.instances.filter((instance) => instance.usage.lastHealthCheckAt && instance.usage.lastHealthStatus).sort((left, right) => Date.parse(right.usage.lastHealthCheckAt) - Date.parse(left.usage.lastHealthCheckAt))[0]?.usage;
-			const permissionDetails = definition.permissions?.data ?? [];
-			const canWrite = permissionDetails.some((permission) => /(?:^|[.:/_-])(write|create|update|delete|manage|send|admin)(?:$|[.:/_-])/i.test(permission));
-			return {
-				id: definition.id,
-				accountLabel: row.accountLabel,
-				accountOrdinal: row.accountOrdinal,
-				accountCount: row.accountCount,
-				displayName: definition.displayName,
-				description: definition.description,
-				...definition.branding ? { branding: definition.branding } : {},
-				category: definition.category,
-				capabilities: definition.capabilities.filter((capability) => capability === "context" || capability === "memory_source" || capability === "tools" || capability === "events"),
-				access: {
-					context: definition.capabilities.includes("context"),
-					memory: definition.capabilities.includes("memory_source"),
-					read: definition.capabilities.includes("context") || definition.capabilities.includes("resources") || definition.capabilities.includes("tools"),
-					write: canWrite
-				},
-				permissionDetails,
-				installed: row.instanceId !== void 0,
-				enabled: row.enabled,
-				status: row.status,
-				instanceId: row.instanceId,
-				lastConnectedAt: row.lastConnectedAt,
-				lastHealthCheckAt: latestHealth?.lastHealthCheckAt,
-				lastHealthStatus: latestHealth?.lastHealthStatus,
-				lastActivityAt: [
-					...row.instances.flatMap((instance) => [
-						instance.lastConnectedAt,
-						instance.usage.lastHealthCheckAt,
-						...instance.audit.map((entry) => entry.at)
-					]),
-					latestSync?.finishedAt,
-					latestSync?.startedAt,
-					latestLearning?.finishedAt,
-					latestLearning?.startedAt
-				].filter((value) => Boolean(value)).sort().at(-1),
-				derivedUnderstandingCount: claimStats?.activeClaims ?? 0,
-				learningFunnel: {
-					indexedItems: sourceItems.filter((item) => !item.deletedAt).length,
-					attributedItems: sourceItems.filter((item) => !item.deletedAt && item.metadata.actorAttributed === true).length,
-					resolvedEntities: claimStats?.resolvedEntities ?? 0,
-					provisionalClaims: claimStats?.provisionalClaims ?? 0,
-					activeClaims: claimStats?.activeClaims ?? 0,
-					evidenceCount: claimStats?.evidenceCount ?? 0,
-					lastEvidenceAt: claimStats?.lastEvidenceAt
-				},
-				knowledgeItemCount: sourceItems.filter((item) => !item.deletedAt).length,
-				lastSyncAt: latestSync?.finishedAt ?? latestSync?.startedAt,
-				lastSyncStatus: latestSync?.status,
-				lastSyncError: latestSync?.error,
-				learning: latestLearning ? {
-					status: latestLearning.status,
-					phase: latestLearning.phase,
-					itemsDiscovered: latestLearning.itemsDiscovered,
-					itemsIndexed: latestLearning.itemsIndexed,
-					candidatesCreated: latestLearning.candidatesCreated,
-					mode: latestLearning.mode,
-					attemptCount: latestLearning.attemptCount,
-					nextRunAt: nextScheduledLearning?.nextRunAt ?? latestLearning.nextRunAt,
-					error: latestLearning.error,
-					updatedAt: latestLearning.updatedAt
-				} : void 0
-			};
-		});
-	}).sort((left, right) => {
-		if (left.installed !== right.installed) return left.installed ? -1 : 1;
-		return left.displayName.localeCompare(right.displayName);
-	});
-}
-//#endregion
-export { USER_CONTEXT_MEMORY_KINDS, facetForMemoryKind, isPersonalContextConnector, isUserContextMemoryKind, isUserContextRecord, originForMemoryRecord, projectPersonalContextSources, projectUserContextRecord, recordsDerivedFromPersonalContextSource };

package/dist/src/user-context/source-recommendations.d.ts

@@ -1,13 +0,0 @@
-import type { ConnectorDefinition } from '../connectors/types.js';
-type TaskSummary = {
-    id: string;
-    title: string;
-    body?: string;
-};
-export declare function buildTaskSourceRecommendations(definitions: ConnectorDefinition[], installedConnectorIds: Set<string>, tasks: TaskSummary[]): {
-    sourceId: string;
-    sourceName: string;
-    taskId: string;
-    taskTitle: string;
-}[];
-export {};

package/dist/src/user-context/source-recommendations.js

@@ -1,85 +0,0 @@
-//#region src/user-context/source-recommendations.ts
-const DOMAINS = [
-	[
-		"calendar",
-		"schedule",
-		"meeting",
-		"deadline",
-		"event",
-		"日历",
-		"日程",
-		"会议",
-		"截止",
-		"预约"
-	],
-	[
-		"email",
-		"gmail",
-		"outlook",
-		"mail",
-		"inbox",
-		"邮件",
-		"邮箱",
-		"收件箱"
-	],
-	[
-		"docs",
-		"document",
-		"notion",
-		"drive",
-		"knowledge",
-		"wiki",
-		"文档",
-		"知识库",
-		"资料"
-	],
-	[
-		"github",
-		"gitlab",
-		"code",
-		"repository",
-		"issue",
-		"代码",
-		"仓库",
-		"开发"
-	],
-	[
-		"slack",
-		"teams",
-		"chat",
-		"message",
-		"消息",
-		"群聊",
-		"沟通"
-	]
-];
-function buildTaskSourceRecommendations(definitions, installedConnectorIds, tasks) {
-	const recommendations = [];
-	for (const definition of definitions) {
-		if (definition.understanding?.mode !== "activity") continue;
-		if (installedConnectorIds.has(definition.id)) continue;
-		const sourceText = [
-			definition.id,
-			definition.displayName,
-			definition.description,
-			...definition.tags ?? []
-		].join(" ").toLowerCase();
-		for (const task of tasks) {
-			const taskText = `${task.title} ${task.body ?? ""}`.toLowerCase();
-			let score = 0;
-			for (const keywords of DOMAINS) if (keywords.some((keyword) => sourceText.includes(keyword)) && keywords.some((keyword) => taskText.includes(keyword))) score += 3;
-			const genericTerms = taskText.match(/[a-z][a-z0-9_-]{3,}/g) ?? [];
-			score += new Set(genericTerms.filter((term) => sourceText.includes(term))).size;
-			if (score > 0) recommendations.push({
-				sourceId: definition.id,
-				sourceName: definition.displayName,
-				taskId: task.id,
-				taskTitle: task.title,
-				score
-			});
-		}
-	}
-	return recommendations.sort((left, right) => right.score - left.score || left.sourceName.localeCompare(right.sourceName)).filter((item, index, all) => all.findIndex((candidate) => candidate.sourceId === item.sourceId) === index).slice(0, 3).map(({ score: _score, ...item }) => item);
-}
-//#endregion
-export { buildTaskSourceRecommendations };