@xopcai/xopc 0.0.248 → 0.0.249

package/dist/src/storage/sqlite/remote-context-repository.d.ts

@@ -1,3 +0,0 @@
-export type RemoteContextKind = 'understanding' | 'focus';
-/** Check all provenance, including older evidence, without loading private excerpts. */
-export declare function remoteContextEligibleIds(kind: RemoteContextKind, ids: string[]): Set<string>;

package/dist/src/storage/sqlite/remote-context-repository.js

@@ -1,40 +0,0 @@
-import { getSqliteDatabase } from "./transaction.js";
-import { USER_CONTEXT_PRINCIPAL_ID } from "../../user-context/domain.js";
-//#region src/storage/sqlite/remote-context-repository.ts
-/** Check all provenance, including older evidence, without loading private excerpts. */
-function remoteContextEligibleIds(kind, ids) {
-	if (!ids.length) return /* @__PURE__ */ new Set();
-	if (ids.length > 200) throw new Error("Context candidate limit exceeded");
-	const focus = kind === "focus";
-	const table = focus ? "user_focuses" : "user_understandings";
-	const versions = focus ? "user_focus_versions" : "user_understanding_versions";
-	const links = focus ? "user_focus_evidence_links" : "understanding_evidence_links";
-	const id = focus ? "focus_id" : "understanding_id";
-	const rows = getSqliteDatabase().prepare(`
-    SELECT u.${id} AS id, v.created_by, u.explicitness,
-      COUNT(e.evidence_id) AS evidence_count,
-      MAX(CASE WHEN e.evidence_id IS NOT NULL AND (
-        (e.processing_policy IS NOT NULL AND e.processing_policy <> 'remote_allowed')
-        OR e.trust_level = 'untrusted' OR e.principal_id <> u.principal_id
-        OR (e.source_run_id IS NOT NULL AND (g.grant_id IS NULL OR g.status <> 'active' OR g.processing_policy <> 'remote_allowed'))
-        OR (e.source_type = 'connector' AND (e.processing_policy IS NULL OR e.source_run_id IS NULL))
-        OR (e.processing_policy IS NULL AND e.source_type <> 'user' AND e.trust_level <> 'owner')
-      ) THEN 1 ELSE 0 END) AS blocked
-    FROM ${table} u
-    JOIN ${versions} v ON v.version_id = u.current_version_id
-    LEFT JOIN ${versions} history ON history.${id} = u.${id}
-    LEFT JOIN ${links} l ON l.version_id = history.version_id
-    LEFT JOIN context_evidence e ON e.evidence_id = l.evidence_id
-    LEFT JOIN understanding_source_runs r ON r.run_id = e.source_run_id
-    LEFT JOIN understanding_source_grants g ON g.grant_id = r.grant_id
-    WHERE u.principal_id = ? AND u.${id} IN (${ids.map(() => "?").join(",")})
-    ${focus ? `AND (u.source_run_id IS NULL OR EXISTS (
-      SELECT 1 FROM understanding_source_runs fr JOIN understanding_source_grants fg ON fg.grant_id = fr.grant_id
-      WHERE fr.run_id = u.source_run_id AND fg.status = 'active' AND fg.processing_policy = 'remote_allowed'
-    ))` : ""}
-    GROUP BY u.${id}
-  `).all(USER_CONTEXT_PRINCIPAL_ID, ...ids);
-	return new Set(rows.filter((row) => !row.blocked && (row.evidence_count > 0 || row.explicitness === "explicit" && row.created_by === "user")).map((row) => row.id));
-}
-//#endregion
-export { remoteContextEligibleIds };

package/dist/src/storage/sqlite/understanding-focus-exclusions.d.ts

@@ -1,2 +0,0 @@
-export declare function listUnderstandingFocusExclusions(): Map<string, string[]>;
-export declare function setUnderstandingFocusExclusion(understandingId: string, focusId: string, excluded: boolean): void;

package/dist/src/storage/sqlite/understanding-focus-exclusions.js

@@ -1,24 +0,0 @@
-import { getSqliteDatabase } from "./transaction.js";
-import { notifyUserContextChange } from "../../user-context/changes.js";
-//#region src/storage/sqlite/understanding-focus-exclusions.ts
-function listUnderstandingFocusExclusions() {
-	const rows = getSqliteDatabase().prepare("SELECT understanding_id, focus_id FROM understanding_focus_exclusions").all();
-	const result = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const ids = result.get(row.understanding_id) ?? [];
-		ids.push(row.focus_id);
-		result.set(row.understanding_id, ids);
-	}
-	return result;
-}
-function setUnderstandingFocusExclusion(understandingId, focusId, excluded) {
-	const db = getSqliteDatabase();
-	if (excluded) db.prepare("INSERT OR IGNORE INTO understanding_focus_exclusions (understanding_id, focus_id, created_at) VALUES (?, ?, ?)").run(understandingId, focusId, Date.now());
-	else db.prepare("DELETE FROM understanding_focus_exclusions WHERE understanding_id = ? AND focus_id = ?").run(understandingId, focusId);
-	notifyUserContextChange({
-		kind: "understanding",
-		id: understandingId
-	});
-}
-//#endregion
-export { listUnderstandingFocusExclusions, setUnderstandingFocusExclusion };

package/dist/src/storage/sqlite/user-context-quality-repository.d.ts

@@ -1,49 +0,0 @@
-export type UserUnderstandingQualityMetrics = {
-    windowDays: number;
-    since: string;
-    records: {
-        total: number;
-        candidate: number;
-        active: number;
-        rejected: number;
-        needsReview: number;
-        stale: number;
-        archived: number;
-        agingCandidates: number;
-        explicit: number;
-        inferred: number;
-        averageConfidence: number | null;
-    };
-    decisions: {
-        total: number;
-        acceptanceRate: number | null;
-    };
-    recall: {
-        total: number;
-        helpful: number;
-        notHelpful: number;
-        mixed: number;
-        irrelevant: number;
-        helpfulRate: number | null;
-    };
-    quickUnderstanding: {
-        sourcesAuthorized: number;
-        sourcesCollected: number;
-        sourceCoverage: number | null;
-        bootstrapJobs: number;
-        successfulBootstrapRate: number | null;
-        medianBootstrapDurationMs: number | null;
-    };
-};
-export type UnderstandingFeedbackSummary = {
-    understandingId: string;
-    helpful: number;
-    irrelevant: number;
-    total: number;
-};
-export declare function summarizeUnderstandingFeedback(understandingIds: string[]): UnderstandingFeedbackSummary[];
-export declare function summarizeUserUnderstandingQuality(options?: {
-    windowDays?: number;
-    agingCandidateDays?: number;
-    nowMs?: number;
-}): UserUnderstandingQualityMetrics;

package/dist/src/storage/sqlite/user-context-quality-repository.js

@@ -1,118 +0,0 @@
-import { getSqliteDatabase } from "./transaction.js";
-import { USER_CONTEXT_PRINCIPAL_ID } from "../../user-context/domain.js";
-//#region src/storage/sqlite/user-context-quality-repository.ts
-function summarizeUnderstandingFeedback(understandingIds) {
-	const ids = [...new Set(understandingIds.filter(Boolean))].slice(0, 1e3);
-	if (!ids.length) return [];
-	const rows = getSqliteDatabase().prepare(`
-    SELECT object_id, rating, COUNT(*) AS count
-    FROM context_feedback
-    WHERE object_type = 'understanding' AND object_id IN (${ids.map(() => "?").join(", ")})
-    GROUP BY object_id, rating
-  `).all(...ids);
-	const summaries = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const current = summaries.get(row.object_id) ?? {
-			understandingId: row.object_id,
-			helpful: 0,
-			irrelevant: 0,
-			total: 0
-		};
-		if (row.rating === "helpful") current.helpful += row.count;
-		if (row.rating === "irrelevant") current.irrelevant += row.count;
-		current.total += row.count;
-		summaries.set(row.object_id, current);
-	}
-	return [...summaries.values()];
-}
-function rate(numerator, denominator) {
-	return denominator > 0 ? Math.round(numerator / denominator * 1e4) / 1e4 : null;
-}
-function median(values) {
-	if (!values.length) return null;
-	const sorted = values.toSorted((left, right) => left - right);
-	const middle = Math.floor(sorted.length / 2);
-	return sorted.length % 2 ? sorted[middle] : Math.round((sorted[middle - 1] + sorted[middle]) / 2);
-}
-function summarizeUserUnderstandingQuality(options = {}) {
-	const nowMs = options.nowMs ?? Date.now();
-	const windowDays = Math.max(1, Math.min(365, Math.floor(options.windowDays ?? 30)));
-	const sinceMs = nowMs - windowDays * 864e5;
-	const agingCutoff = nowMs - Math.max(1, Math.min(windowDays, Math.floor(options.agingCandidateDays ?? 7))) * 864e5;
-	const db = getSqliteDatabase();
-	const rows = db.prepare(`SELECT status, explicitness, confidence, created_at, updated_at
-    FROM user_understandings WHERE principal_id = ?`).all(USER_CONTEXT_PRINCIPAL_ID);
-	const records = {
-		total: rows.length,
-		candidate: 0,
-		active: 0,
-		rejected: 0,
-		needsReview: 0,
-		stale: 0,
-		archived: 0,
-		agingCandidates: 0,
-		explicit: 0,
-		inferred: 0,
-		averageConfidence: rows.length ? Math.round(rows.reduce((sum, row) => sum + row.confidence, 0) / rows.length * 1e4) / 1e4 : null
-	};
-	for (const row of rows) {
-		if (row.status === "candidate") records.candidate += 1;
-		if (row.status === "active") records.active += 1;
-		if (row.status === "rejected") records.rejected += 1;
-		if (row.status === "needs_review") records.needsReview += 1;
-		if (row.status === "stale") records.stale += 1;
-		if (row.status === "archived") records.archived += 1;
-		if (row.status === "candidate" && row.created_at <= agingCutoff) records.agingCandidates += 1;
-		if (row.explicitness === "explicit") records.explicit += 1;
-		if (row.explicitness === "inferred") records.inferred += 1;
-	}
-	const recentDecisions = rows.filter((row) => (row.status === "active" || row.status === "rejected") && row.updated_at >= sinceMs);
-	const accepted = recentDecisions.filter((row) => row.status === "active").length;
-	const feedback = db.prepare(`SELECT DISTINCT f.feedback_id, f.rating
-    FROM context_feedback f
-    JOIN context_runs r ON r.context_run_id = f.context_run_id
-    WHERE f.created_at >= ? AND EXISTS (
-      SELECT 1 FROM context_run_items i
-      WHERE i.context_run_id = r.context_run_id
-        AND i.object_type = 'understanding' AND i.decision = 'selected'
-    )`).all(sinceMs);
-	const recall = {
-		total: feedback.length,
-		helpful: feedback.filter((row) => row.rating === "helpful").length,
-		notHelpful: feedback.filter((row) => [
-			"wrong",
-			"stale",
-			"sensitive"
-		].includes(row.rating)).length,
-		mixed: 0,
-		irrelevant: feedback.filter((row) => row.rating === "irrelevant").length,
-		helpfulRate: null
-	};
-	recall.helpfulRate = rate(recall.helpful, recall.total);
-	const sourceRows = db.prepare(`SELECT last_collected_at
-    FROM understanding_source_grants WHERE status = 'active'`).all();
-	const bootstrapRows = db.prepare(`SELECT status, started_at, finished_at
-    FROM connector_learning_jobs WHERE mode = 'bootstrap' AND created_at >= ?`).all(sinceMs);
-	const completedBootstraps = bootstrapRows.filter((row) => row.status === "completed");
-	const bootstrapDurations = completedBootstraps.flatMap((row) => row.started_at !== null && row.finished_at !== null && row.finished_at >= row.started_at ? [row.finished_at - row.started_at] : []);
-	return {
-		windowDays,
-		since: new Date(sinceMs).toISOString(),
-		records,
-		decisions: {
-			total: recentDecisions.length,
-			acceptanceRate: rate(accepted, recentDecisions.length)
-		},
-		recall,
-		quickUnderstanding: {
-			sourcesAuthorized: sourceRows.length,
-			sourcesCollected: sourceRows.filter((row) => row.last_collected_at !== null).length,
-			sourceCoverage: rate(sourceRows.filter((row) => row.last_collected_at !== null).length, sourceRows.length),
-			bootstrapJobs: bootstrapRows.length,
-			successfulBootstrapRate: rate(completedBootstraps.length, bootstrapRows.length),
-			medianBootstrapDurationMs: median(bootstrapDurations)
-		}
-	};
-}
-//#endregion
-export { summarizeUnderstandingFeedback, summarizeUserUnderstandingQuality };

package/dist/src/storage/sqlite/user-context-repository.d.ts

@@ -1,85 +0,0 @@
-import { type CollaborationRule, type ContextEvidence, type PersonalizationItem, type UnderstandingStatus, type UserContextScope, type UserProfile, type UserUnderstanding } from '../../user-context/domain.js';
-export type UnderstandingStatusEvent = {
-    id: string;
-    understandingId: string;
-    fromStatus?: UnderstandingStatus;
-    toStatus: UnderstandingStatus;
-    actorType: 'user' | 'runtime' | 'migration';
-    source: string;
-    createdAt: number;
-};
-export declare function getUserProfile(principalId?: string): UserProfile;
-export declare function updateUserProfile(patch: Partial<Pick<UserProfile, 'callName' | 'role' | 'primaryGoal' | 'pronouns' | 'timezone' | 'locale' | 'accessibility'>>, principalId?: string): UserProfile;
-export type CreateUnderstandingInput = Omit<UserUnderstanding, 'id' | 'versionId' | 'createdAt' | 'updatedAt' | 'statement' | 'payload'> & {
-    statement: string;
-    payload?: Record<string, unknown>;
-    createdBy: 'user' | 'runtime' | 'connector' | 'consolidation';
-    changeReason: string;
-};
-export declare function createUnderstanding(input: CreateUnderstandingInput, principalId?: string): UserUnderstanding;
-export declare function getUnderstanding(id: string): UserUnderstanding | undefined;
-export declare function listUnderstandings(statuses?: UnderstandingStatus[], principalId?: string, limit?: number): UserUnderstanding[];
-export declare function searchActiveUnderstandings(query: string, limit?: number): Array<{
-    understanding: UserUnderstanding;
-    score: number;
-}>;
-export declare function reviseUnderstanding(id: string, statement: string, options: {
-    payload?: Record<string, unknown>;
-    canonicalKey?: string;
-    explicitness?: UserUnderstanding['explicitness'];
-    confidence?: number;
-    changeReason: string;
-}): UserUnderstanding;
-export declare function setUnderstandingStatus(id: string, status: UnderstandingStatus, options?: {
-    explicitness?: UserUnderstanding['explicitness'];
-    confidence?: number;
-    actorType?: UnderstandingStatusEvent['actorType'];
-    source?: string;
-}): UserUnderstanding;
-export declare function closeUnderstandingValidity(id: string, validTo?: number): UserUnderstanding;
-export declare function rejectUnderstanding(id: string, reason: string, actorType?: UnderstandingStatusEvent['actorType']): UserUnderstanding;
-export declare function listUnderstandingStatusEvents(id: string): UnderstandingStatusEvent[];
-export declare function deleteUnderstanding(id: string): boolean;
-export declare function isUnderstandingSuppressed(canonicalKey: string, scope: UserContextScope, principalId?: string): boolean;
-export declare function createCollaborationRule(input: Pick<CollaborationRule, 'category' | 'priority' | 'scope' | 'conditions' | 'statement'>, principalId?: string): CollaborationRule;
-export declare function getCollaborationRule(id: string): CollaborationRule | undefined;
-export declare function listCollaborationRules(principalId?: string): CollaborationRule[];
-export declare function reviseCollaborationRule(id: string, statement: string): CollaborationRule;
-export declare function setCollaborationRuleStatus(id: string, status: CollaborationRule['status']): CollaborationRule;
-export declare function deleteCollaborationRule(id: string): boolean;
-export declare function createContextEvidence(input: Omit<ContextEvidence, 'id' | 'ingestedAt' | 'createdAt'> & {
-    ingestedAt?: number;
-}, principalId?: string): ContextEvidence;
-export declare function linkUnderstandingEvidence(versionId: string, evidenceId: string, relation: 'supports' | 'contradicts' | 'supersedes', confidence: number): void;
-export declare function listUnderstandingEvidence(understandingId: string, relation?: 'supports' | 'contradicts' | 'supersedes'): ContextEvidence[];
-/** Latest source labels for ranking, without fetching evidence bodies per candidate. */
-export declare function understandingSourceBuckets(ids: string[]): Map<string, string>;
-export declare function recordContextRun(input: {
-    turnId: string;
-    sessionKey: string;
-    query: string;
-    budget: number;
-    durationMs: number;
-    items: PersonalizationItem[];
-    principalId?: string;
-}): string;
-export declare function getTurnPersonalization(turnId: string): {
-    runId: string;
-    items: PersonalizationItem[];
-} | undefined;
-export declare function recordContextFeedback(input: {
-    turnId: string;
-    runId: string;
-    objectType?: PersonalizationItem['objectType'];
-    objectId?: string;
-    rating: 'helpful' | 'irrelevant' | 'wrong' | 'stale' | 'sensitive';
-    reason?: string;
-}): void;
-export declare function hasContextConsent(understandingId: string, sessionKey: string): boolean;
-export declare function consumeContextConsent(understandingId: string, sessionKey: string): 'granted' | 'denied' | 'missing';
-export declare function ensureContextConsent(understandingId: string, sessionKey: string, purpose: string): {
-    id: string;
-    understandingId: string;
-    purpose: string;
-};
-export declare function decideContextConsent(id: string, decision: 'once' | 'session' | 'always' | 'deny'): boolean;