@xopcai/xopc 0.0.225 → 0.0.227

package/dist/src/user-context/relationships/indexer.js

@@ -0,0 +1,185 @@
+import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
+import { getUserPeopleIndexState, replaceUserPeopleIndex } from "../../storage/sqlite/user-people-repository.js";
+import { listKnowledgeSourceItems } from "../../storage/sqlite/knowledge-repository.js";
+import "../../storage/sqlite/index.js";
+import { listUnderstandingSourceGrants } from "../sources/repository.js";
+import { createHash } from "node:crypto";
+//#region src/user-context/relationships/indexer.ts
+function hash(value) {
+	return createHash("sha256").update(value).digest("hex").slice(0, 20);
+}
+function normalized(value) {
+	return value?.trim().toLocaleLowerCase() || void 0;
+}
+function readSignal(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const row = value;
+	const read = (key) => typeof row[key] === "string" && row[key].trim() ? row[key].trim().slice(0, 160) : void 0;
+	const signal = {
+		name: read("name"),
+		email: read("email"),
+		username: read("username")
+	};
+	return signal.name || signal.email || signal.username ? signal : void 0;
+}
+function providerScope(sourceInstanceId) {
+	if (!sourceInstanceId.startsWith("composio:")) return sourceInstanceId.toLocaleLowerCase();
+	return sourceInstanceId.split(":")[1]?.toLocaleLowerCase() ?? sourceInstanceId.toLocaleLowerCase();
+}
+function personIdentityKey(signal, sourceInstanceId) {
+	const email = normalized(signal.email);
+	if (email) return `email:${email}`;
+	const username = normalized(signal.username);
+	if (username) return `provider:${providerScope(sourceInstanceId)}:${username}`;
+	const name = normalized(signal.name);
+	return name ? `name:${sourceInstanceId.toLocaleLowerCase()}:${name}` : void 0;
+}
+function personIdForIdentity(signal, sourceInstanceId) {
+	const key = personIdentityKey(signal, sourceInstanceId);
+	return key ? `person_${hash(key)}` : void 0;
+}
+function inferredKind(signal) {
+	const name = normalized(signal.name) ?? "";
+	const username = normalized(signal.username) ?? "";
+	const emailLocal = (normalized(signal.email) ?? "").split("@")[0] ?? "";
+	if (/\[bot\]|(?:^|[-_.])bot(?:$|[-_.])|bot$/.test(`${name} ${username}`)) return "bot";
+	if (/^(?:no[-_.]?reply|do[-_.]?not[-_.]?reply|notifications?|alerts?|mailer[-_.]?daemon)(?:$|[-+_.])/.test(emailLocal)) return "service";
+	if (/^(?:team|group|all|everyone|support|help|sales|contact)(?:$|[-+_.])/.test(emailLocal)) return "group";
+	if (!signal.name && !signal.email && signal.username) return "unknown";
+	return "person";
+}
+function confidence(signal) {
+	if (signal.email) return signal.name ? .95 : .88;
+	if (signal.username) return signal.name ? .86 : .72;
+	return .55;
+}
+function observedAt(item) {
+	const value = Date.parse(item.occurredAt ?? item.sourceUpdatedAt ?? item.updatedAt);
+	return Number.isFinite(value) ? value : Date.now();
+}
+function handle(personId, type, value, sourceInstanceId, time) {
+	return {
+		id: `handle_${hash(`${type}:${normalized(value)}:${sourceInstanceId}`)}`,
+		type,
+		value,
+		sourceInstanceId,
+		verification: type === "display_name" ? "inferred" : "observed",
+		firstObservedAt: time,
+		lastObservedAt: time
+	};
+}
+function activeConnectorSources() {
+	return new Set(listUnderstandingSourceGrants().flatMap((grant) => {
+		const sourceInstanceId = typeof grant.config.sourceInstanceId === "string" ? grant.config.sourceInstanceId.trim() : "";
+		if (sourceInstanceId) return [sourceInstanceId];
+		const connectorId = typeof grant.config.connectorId === "string" ? grant.config.connectorId.trim() : "";
+		const accountId = typeof grant.config.accountId === "string" ? grant.config.accountId.trim() : "";
+		return connectorId && accountId ? [`composio:${connectorId}:${accountId}`] : [];
+	}));
+}
+function loadActiveSourceItems() {
+	const activeSources = activeConnectorSources();
+	const items = [];
+	let offset = 0;
+	while (true) {
+		const page = listKnowledgeSourceItems({
+			includeDeleted: false,
+			limit: 500,
+			offset
+		});
+		items.push(...page.filter((item) => item.synthesisPipeline === "connected_knowledge" && item.sensitivity !== "secret" && item.sensitivity !== "regulated" && item.metadata.observationKind !== "inventory" && (!item.sourceInstanceId.startsWith("composio:") || activeSources.has(item.sourceInstanceId))));
+		if (page.length < 500) break;
+		offset += page.length;
+	}
+	return items;
+}
+function currentIndexRevision() {
+	const db = getSqliteDatabase();
+	return {
+		sourceChangeSequence: Number(db.prepare("SELECT COALESCE(MAX(sequence), 0) AS value FROM knowledge_source_changes").get().value),
+		sourceGrantsUpdatedAt: Number(db.prepare("SELECT COALESCE(MAX(updated_at), 0) AS value FROM understanding_source_grants").get().value)
+	};
+}
+function buildUserPeopleIndex(items) {
+	const owners = new Set(items.flatMap((item) => Array.isArray(item.metadata.ownerIdentities) ? item.metadata.ownerIdentities.filter((value) => typeof value === "string").map((value) => value.trim().toLocaleLowerCase()).filter(Boolean) : []));
+	const people = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const values = Array.isArray(item.metadata.personEntities) ? item.metadata.personEntities : [];
+		const seenInItem = /* @__PURE__ */ new Set();
+		for (const value of values) {
+			const signal = readSignal(value);
+			if (!signal) continue;
+			const strongIdentity = normalized(signal.email) ?? normalized(signal.username);
+			if (strongIdentity && owners.has(strongIdentity)) continue;
+			const identityKey = personIdentityKey(signal, item.sourceInstanceId);
+			const id = personIdForIdentity(signal, item.sourceInstanceId);
+			if (!identityKey || !id || seenInItem.has(identityKey)) continue;
+			seenInItem.add(identityKey);
+			const time = observedAt(item);
+			const name = signal.name ?? signal.email ?? signal.username;
+			const current = people.get(identityKey) ?? {
+				id,
+				displayName: name,
+				inferredKind: inferredKind(signal),
+				confidence: confidence(signal),
+				firstObservedAt: time,
+				lastObservedAt: time,
+				handles: /* @__PURE__ */ new Map(),
+				sources: /* @__PURE__ */ new Map()
+			};
+			if (signal.name && (!current.displayName || current.displayName.includes("@"))) current.displayName = signal.name;
+			current.inferredKind = current.inferredKind === "unknown" ? inferredKind(signal) : current.inferredKind;
+			current.confidence = Math.max(current.confidence, confidence(signal));
+			current.firstObservedAt = Math.min(current.firstObservedAt, time);
+			current.lastObservedAt = Math.max(current.lastObservedAt, time);
+			for (const [type, displayValue] of [
+				["email", signal.email],
+				["username", signal.username],
+				["display_name", signal.name]
+			]) {
+				if (!displayValue) continue;
+				const next = handle(id, type, displayValue, item.sourceInstanceId, time);
+				const key = `${type}:${normalized(displayValue)}:${item.sourceInstanceId}`;
+				const previous = current.handles.get(key);
+				if (previous) {
+					previous.firstObservedAt = Math.min(previous.firstObservedAt, time);
+					previous.lastObservedAt = Math.max(previous.lastObservedAt, time);
+				} else current.handles.set(key, next);
+			}
+			const source = current.sources.get(item.sourceInstanceId) ?? {
+				sourceInstanceId: item.sourceInstanceId,
+				interactionCount: 0,
+				firstObservedAt: time,
+				lastObservedAt: time
+			};
+			source.interactionCount += 1;
+			source.firstObservedAt = Math.min(source.firstObservedAt, time);
+			source.lastObservedAt = Math.max(source.lastObservedAt, time);
+			current.sources.set(item.sourceInstanceId, source);
+			people.set(identityKey, current);
+		}
+	}
+	return [...people.values()].map((person) => ({
+		id: person.id,
+		displayName: person.displayName,
+		inferredKind: person.inferredKind,
+		confidence: person.confidence,
+		firstObservedAt: person.firstObservedAt,
+		lastObservedAt: person.lastObservedAt,
+		handles: [...person.handles.values()],
+		sources: [...person.sources.values()]
+	}));
+}
+function rebuildUserPeopleIndex() {
+	const revision = currentIndexRevision();
+	const entries = buildUserPeopleIndex(loadActiveSourceItems());
+	replaceUserPeopleIndex(entries, revision);
+	return entries;
+}
+function ensureUserPeopleIndex() {
+	const revision = currentIndexRevision();
+	const state = getUserPeopleIndexState();
+	if (!state || state.sourceChangeSequence !== revision.sourceChangeSequence || state.sourceGrantsUpdatedAt !== revision.sourceGrantsUpdatedAt) rebuildUserPeopleIndex();
+}
+//#endregion
+export { buildUserPeopleIndex, ensureUserPeopleIndex, personIdForIdentity, personIdentityKey, rebuildUserPeopleIndex };

package/dist/src/user-context/relationships/service.d.ts

@@ -0,0 +1,22 @@
+import type { UserPerson, UserPersonKind } from './types.js';
+export declare function listUserRelationships(options?: {
+    query?: string;
+    kind?: UserPersonKind;
+    sourceInstanceId?: string;
+    includeHidden?: boolean;
+    hiddenOnly?: boolean;
+    cursor?: string;
+    limit?: number;
+}): {
+    nextCursor?: string;
+    items: UserPerson[];
+    summary: import("./types.js").UserRelationshipSummary;
+    total: number;
+};
+export declare function getUserRelationship(personId: string): UserPerson | null;
+export declare function patchUserRelationship(personId: string, patch: {
+    displayName?: string | null;
+    kind?: UserPersonKind | null;
+    hidden?: boolean;
+}): UserPerson | null;
+export declare function mergeUserRelationships(sourcePersonId: string, targetPersonId: string): UserPerson | null;

package/dist/src/user-context/relationships/service.js

@@ -0,0 +1,50 @@
+import { listUnderstandings } from "../../storage/sqlite/user-context-repository.js";
+import { getUserPerson, listUserPeople, mergeUserPeople, summarizeUserPeople, updateUserPerson } from "../../storage/sqlite/user-people-repository.js";
+import "../../storage/sqlite/index.js";
+import { ensureUserPeopleIndex } from "./indexer.js";
+//#region src/user-context/relationships/service.ts
+function withUnderstanding(person) {
+	const understanding = listUnderstandings().find((item) => item.kind === "relationship" && item.payload.personId === person.id && !["archived", "rejected"].includes(item.status));
+	return understanding ? {
+		...person,
+		relationshipUnderstanding: {
+			id: understanding.id,
+			statement: understanding.statement,
+			status: understanding.status
+		}
+	} : person;
+}
+function listUserRelationships(options = {}) {
+	ensureUserPeopleIndex();
+	const offset = options.cursor && /^\d+$/.test(options.cursor) ? Number(options.cursor) : 0;
+	const result = listUserPeople({
+		query: options.query,
+		kind: options.kind,
+		sourceInstanceId: options.sourceInstanceId,
+		includeHidden: options.includeHidden,
+		hiddenOnly: options.hiddenOnly,
+		offset,
+		limit: options.limit
+	});
+	return {
+		items: result.items.map(withUnderstanding),
+		summary: summarizeUserPeople(),
+		total: result.total,
+		...result.nextOffset === void 0 ? {} : { nextCursor: String(result.nextOffset) }
+	};
+}
+function getUserRelationship(personId) {
+	ensureUserPeopleIndex();
+	const person = getUserPerson(personId);
+	return person ? withUnderstanding(person) : null;
+}
+function patchUserRelationship(personId, patch) {
+	const person = updateUserPerson(personId, patch);
+	return person ? withUnderstanding(person) : null;
+}
+function mergeUserRelationships(sourcePersonId, targetPersonId) {
+	const person = mergeUserPeople(sourcePersonId, targetPersonId);
+	return person ? withUnderstanding(person) : null;
+}
+//#endregion
+export { getUserRelationship, listUserRelationships, mergeUserRelationships, patchUserRelationship };

package/dist/src/user-context/relationships/types.d.ts

@@ -0,0 +1,55 @@
+export declare const USER_PERSON_KINDS: readonly ["person", "bot", "service", "group", "unknown"];
+export type UserPersonKind = typeof USER_PERSON_KINDS[number];
+export type UserPersonHandle = {
+    id: string;
+    type: 'email' | 'provider_user' | 'username' | 'display_name';
+    value: string;
+    sourceInstanceId: string;
+    verification: 'observed' | 'inferred' | 'user_confirmed';
+    firstObservedAt: number;
+    lastObservedAt: number;
+};
+export type UserPersonSource = {
+    sourceInstanceId: string;
+    connectorId?: string;
+    toolkit?: string;
+    interactionCount: number;
+    firstObservedAt: number;
+    lastObservedAt: number;
+};
+export type UserPerson = {
+    id: string;
+    displayName: string;
+    kind: UserPersonKind;
+    hidden: boolean;
+    confidence: number;
+    primaryHandle?: string;
+    interactionCount: number;
+    firstObservedAt: number;
+    lastObservedAt: number;
+    handles: UserPersonHandle[];
+    sources: UserPersonSource[];
+    relationshipUnderstanding?: {
+        id: string;
+        statement: string;
+        status: 'candidate' | 'active' | 'needs_review' | 'stale' | 'archived' | 'rejected';
+    };
+};
+export type UserRelationshipSummary = {
+    people: number;
+    automatedAccounts: number;
+    needsReview: number;
+    hidden: number;
+    sources: number;
+    lastUpdatedAt?: number;
+};
+export type UserPersonIndexEntry = {
+    id: string;
+    displayName: string;
+    inferredKind: UserPersonKind;
+    confidence: number;
+    firstObservedAt: number;
+    lastObservedAt: number;
+    handles: UserPersonHandle[];
+    sources: UserPersonSource[];
+};

package/dist/src/user-context/relationships/types.js

@@ -0,0 +1,10 @@
+//#region src/user-context/relationships/types.ts
+const USER_PERSON_KINDS = [
+	"person",
+	"bot",
+	"service",
+	"group",
+	"unknown"
+];
+//#endregion
+export { USER_PERSON_KINDS };

package/dist/src/user-context/sources/repository.d.ts

@@ -55,6 +55,6 @@ export declare function updateUnderstandingSourceRun(id: string, patch: {
 }): UnderstandingSourceRun | null;
 export declare function upsertUserFocus(input: UserFocusInput): UserFocus;
 export declare function listUserFocuses(statuses?: UserFocus['status'][]): UserFocus[];
-export declare function updateUserFocus(id: string, patch: Partial<Pick<UserFocus, 'title' | 'summary' | 'status'>>, nowMs?: number): UserFocus | null;
+export declare function updateUserFocus(id: string, patch: Partial<Pick<UserFocus, 'title' | 'summary' | 'status' | 'validFrom' | 'validTo' | 'reviewAt'>>, nowMs?: number): UserFocus | null;
 export declare function deleteUserFocus(id: string): boolean;
 export {};

package/dist/src/user-context/sources/repository.js

@@ -1,5 +1,6 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
 import "../domain.js";
+import { focusLifecycle } from "../focus-lifecycle.js";
 import { randomUUID } from "node:crypto";
 //#region src/user-context/sources/repository.ts
 function record(value) {
@@ -261,11 +262,16 @@ function updateUserFocus(id, patch, nowMs = Date.now()) {
 	const currentRow = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE focus_id = ?").get(id);
 	if (!currentRow) return null;
 	const current = focusFromRow(currentRow);
-	if ((patch.title ?? current.title) === current.title && (patch.summary ?? current.summary) === current.summary && (patch.status ?? current.status) === current.status) return current;
+	const renewedLifecycle = patch.status === "active" && (current.status !== "active" || current.reviewAt !== void 0 && current.reviewAt <= nowMs || current.validTo !== void 0 && current.validTo <= nowMs) ? focusLifecycle(current.horizon, nowMs) : {};
+	const nextValidFrom = patch.validFrom ?? renewedLifecycle.validFrom ?? current.validFrom;
+	const nextValidTo = patch.validTo ?? renewedLifecycle.validTo ?? current.validTo;
+	const nextReviewAt = patch.reviewAt ?? renewedLifecycle.reviewAt ?? current.reviewAt;
+	if ((patch.title ?? current.title) === current.title && (patch.summary ?? current.summary) === current.summary && (patch.status ?? current.status) === current.status && nextValidFrom === current.validFrom && nextValidTo === current.validTo && nextReviewAt === current.reviewAt) return current;
 	const versionId = randomUUID();
 	runSqliteWriteTransaction((db) => {
 		db.prepare(`UPDATE user_focuses
-      SET title = ?, summary = ?, status = ?, updated_at = ? WHERE focus_id = ?`).run(patch.title ?? current.title, patch.summary ?? current.summary, patch.status ?? current.status, nowMs, id);
+      SET title = ?, summary = ?, status = ?, valid_from = ?, valid_to = ?, review_at = ?, updated_at = ?
+      WHERE focus_id = ?`).run(patch.title ?? current.title, patch.summary ?? current.summary, patch.status ?? current.status, nextValidFrom ?? null, nextValidTo ?? null, nextReviewAt ?? null, nowMs, id);
 		const nextRow = db.prepare("SELECT * FROM user_focuses WHERE focus_id = ?").get(id);
 		db.prepare(`INSERT INTO user_focus_versions (
       version_id, focus_id, title, summary, snapshot_json, created_by, change_reason, created_at

package/dist/src/work-discovery/service.js

@@ -8,8 +8,8 @@ import { buildSessionKey, init_session_key } from "../routing/session-key.js";
 import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 import { init_providers, resolveModel } from "../providers/index.js";
 import { isLocalModelBaseUrl } from "../providers/model-call.js";
-import { createUnderstandingSourceRun, getUnderstandingSourceRun, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant, upsertUserFocus } from "../user-context/sources/repository.js";
 import { focusLifecycle } from "../user-context/focus-lifecycle.js";
+import { createUnderstandingSourceRun, getUnderstandingSourceRun, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant, upsertUserFocus } from "../user-context/sources/repository.js";
 import { allowsRemoteSourceProcessing } from "../user-context/sources/processing-policy.js";
 import { analyzeUnderstandingSources, analyzeWorkContext, workDiscoveryResultMarkdown } from "./analyzer.js";
 import { previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, summarizeWorkContextSnapshot } from "./probe.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xopcai/xopc",
-  "version": "0.0.225",
+  "version": "0.0.227",
   "description": "Local-first personal AI assistant with reviewable user understanding, durable tasks, workflows, automations, and local or cloud models.",
   "type": "module",
   "main": "dist/src/index.js",