@xopcai/xopc 0.0.248 → 0.0.250

package/dist/src/user-context/extraction/semantic.js

@@ -1,148 +0,0 @@
-import { UNDERSTANDING_KINDS } from "../domain.js";
-import { isDurableUnderstandingCandidate } from "../understandingQuality.js";
-import { inferMemorySensitivity } from "../../agent/memory/sensitivity.js";
-import { z } from "zod";
-//#region src/user-context/extraction/semantic.ts
-const UNDERSTANDING_INTENTS = [
-	"memory_create",
-	"memory_query",
-	"memory_confirm",
-	"memory_correct",
-	"memory_forget",
-	"user_assertion",
-	"task_request",
-	"none"
-];
-const EvidenceSchema = z.object({
-	ref: z.string().min(1),
-	quote: z.string().min(1)
-}).strict();
-const CandidateSchema = z.object({
-	factKey: z.string().regex(/^[a-z0-9][a-z0-9:-]{2,119}$/),
-	statement: z.string().min(4).max(600),
-	kind: z.enum(UNDERSTANDING_KINDS),
-	explicitness: z.enum([
-		"explicit",
-		"observed",
-		"inferred"
-	]),
-	durability: z.enum([
-		"ephemeral",
-		"durable",
-		"recurring"
-	]),
-	scopeHint: z.enum([
-		"global",
-		"workspace",
-		"project",
-		"session"
-	]),
-	confidence: z.number().min(0).max(1),
-	importance: z.number().min(0).max(1),
-	sensitivity: z.enum([
-		"normal",
-		"personal",
-		"secret",
-		"regulated"
-	]).optional(),
-	disclosurePolicy: z.enum([
-		"silent",
-		"referenceable",
-		"ask_before_reference"
-	]).optional(),
-	evidence: z.array(EvidenceSchema).min(1).max(8),
-	selfContained: z.boolean(),
-	unresolvedReferences: z.array(z.string()).max(8)
-}).strict();
-const InterpretationSchema = z.object({
-	intent: z.enum(UNDERSTANDING_INTENTS),
-	candidates: z.array(CandidateSchema).max(8),
-	targetUnderstandingIds: z.array(z.string().min(1)).max(8),
-	abstentionReason: z.string().max(500).optional()
-}).strict();
-const CANDIDATE_INTENTS = new Set([
-	"memory_create",
-	"memory_confirm",
-	"memory_correct",
-	"user_assertion"
-]);
-const QUESTION_END = /[?？]\s*$/u;
-function extractJson(raw) {
-	const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(raw)?.[1];
-	const start = raw.indexOf("{");
-	const end = raw.lastIndexOf("}");
-	const candidate = fenced ?? (start >= 0 && end > start ? raw.slice(start, end + 1) : raw);
-	return JSON.parse(candidate);
-}
-function comparableText(value) {
-	return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/g, " ").trim();
-}
-function quoteIsGrounded(quote, source) {
-	return comparableText(source).includes(comparableText(quote));
-}
-function bigramSimilarity(left, right) {
-	const pairs = (value) => {
-		const normalized = comparableText(value).replace(/[^\p{L}\p{N}]/gu, "");
-		const output = /* @__PURE__ */ new Set();
-		for (let index = 0; index < normalized.length - 1; index += 1) output.add(normalized.slice(index, index + 2));
-		return output;
-	};
-	const a = pairs(left);
-	const b = pairs(right);
-	if (!a.size || !b.size) return 0;
-	let overlap = 0;
-	for (const pair of a) if (b.has(pair)) overlap += 1;
-	return 2 * overlap / (a.size + b.size);
-}
-function effectiveExplicitness(intent, declared) {
-	if (intent === "memory_create" || intent === "memory_correct" || intent === "memory_confirm") return declared;
-	return declared === "explicit" ? "observed" : declared;
-}
-function parseSemanticUnderstanding(raw, evidence, allowedTargetIds = []) {
-	let parsed;
-	try {
-		const result = InterpretationSchema.safeParse(extractJson(raw));
-		if (!result.success) return null;
-		parsed = result.data;
-	} catch {
-		return null;
-	}
-	const evidenceByRef = new Map(evidence.map((item) => [item.ref, item]));
-	const allowedTargets = new Set(allowedTargetIds);
-	const candidates = [];
-	if (CANDIDATE_INTENTS.has(parsed.intent)) for (const item of parsed.candidates) {
-		if (!item.selfContained || item.unresolvedReferences.length > 0) continue;
-		if (QUESTION_END.test(item.statement)) continue;
-		if (!isDurableUnderstandingCandidate(item.kind, item.statement)) continue;
-		if (!item.evidence.every((claim) => {
-			const source = evidenceByRef.get(claim.ref);
-			return source?.role === "user" && quoteIsGrounded(claim.quote, source.text);
-		})) continue;
-		if (item.explicitness === "explicit") {
-			const quotedText = item.evidence.map((claim) => claim.quote).join(" ");
-			if (bigramSimilarity(item.statement, quotedText) < .45) continue;
-		}
-		const evidenceRefs = [...new Set(item.evidence.map((claim) => claim.ref))];
-		candidates.push({
-			kind: item.kind,
-			content: item.statement.trim(),
-			canonicalKey: `understanding:${item.kind}:${item.factKey}`,
-			confidence: item.confidence,
-			importance: item.importance,
-			explicitness: effectiveExplicitness(parsed.intent, item.explicitness),
-			durability: item.durability,
-			sensitivity: item.sensitivity ?? inferMemorySensitivity(item.statement),
-			disclosurePolicy: item.disclosurePolicy ?? "referenceable",
-			payload: { scopeHint: item.scopeHint },
-			evidenceRefs
-		});
-	}
-	return {
-		intent: parsed.intent,
-		candidates,
-		targetUnderstandingIds: [...new Set(parsed.targetUnderstandingIds.filter((id) => allowedTargets.has(id)))],
-		...parsed.abstentionReason ? { abstentionReason: parsed.abstentionReason } : {}
-	};
-}
-//#endregion
-export { UNDERSTANDING_INTENTS, parseSemanticUnderstanding };

package/dist/src/user-context/focus-lifecycle.d.ts

@@ -1,2 +0,0 @@
-import type { UserFocus } from './sources/types.js';
-export declare function focusLifecycle(horizon: UserFocus['horizon'], now?: number): Pick<UserFocus, 'validFrom' | 'validTo' | 'reviewAt'>;

package/dist/src/user-context/focus-lifecycle.js

@@ -1,26 +0,0 @@
-//#region src/user-context/focus-lifecycle.ts
-const DAY_MS = 1440 * 60 * 1e3;
-const HORIZON_DAYS = {
-	current: {
-		review: 14,
-		valid: 30
-	},
-	ongoing: {
-		review: 30,
-		valid: 120
-	},
-	long_term: {
-		review: 90,
-		valid: 365
-	}
-};
-function focusLifecycle(horizon, now = Date.now()) {
-	const days = HORIZON_DAYS[horizon];
-	return {
-		validFrom: now,
-		reviewAt: now + days.review * DAY_MS,
-		validTo: now + days.valid * DAY_MS
-	};
-}
-//#endregion
-export { focusLifecycle };

package/dist/src/user-context/manual-understanding.d.ts

@@ -1,12 +0,0 @@
-import type { UnderstandingKind, UserContextScope, UserUnderstanding } from './domain.js';
-export declare function createManualUnderstanding(input: {
-    content: string;
-    kind: UnderstandingKind;
-    scope: UserContextScope;
-    sensitivity: UserUnderstanding['sensitivity'];
-    durability: UserUnderstanding['durability'];
-    disclosurePolicy: UserUnderstanding['disclosurePolicy'];
-}): {
-    understanding: UserUnderstanding;
-    created: boolean;
-};

package/dist/src/user-context/manual-understanding.js

@@ -1,37 +0,0 @@
-import { createUnderstanding, listUnderstandings } from "../storage/sqlite/user-context-repository.js";
-import "../storage/sqlite/index.js";
-import { canonicalUnderstandingKey, findDuplicateUnderstanding } from "./understanding.js";
-//#region src/user-context/manual-understanding.ts
-function createManualUnderstanding(input) {
-	const statement = input.content.trim();
-	const key = canonicalUnderstandingKey(input.kind, statement);
-	const duplicate = findDuplicateUnderstanding(listUnderstandings(), {
-		kind: input.kind,
-		statement,
-		canonicalKey: key,
-		scope: input.scope
-	});
-	if (duplicate) return {
-		understanding: duplicate,
-		created: false
-	};
-	return {
-		understanding: createUnderstanding({
-			kind: input.kind,
-			canonicalKey: key,
-			status: "active",
-			scope: input.scope,
-			explicitness: "explicit",
-			durability: input.durability,
-			sensitivity: input.sensitivity,
-			disclosurePolicy: input.disclosurePolicy,
-			confidence: 1,
-			statement,
-			createdBy: "user",
-			changeReason: "Created with /remember"
-		}),
-		created: true
-	};
-}
-//#endregion
-export { createManualUnderstanding };

package/dist/src/user-context/planner.d.ts

@@ -1,17 +0,0 @@
-import type { AgentMessage } from '@earendil-works/pi-agent-core';
-import type { UserContextPlan } from '../agent/memory/context/types.js';
-export declare function prependAgentContext(message: AgentMessage, block: string): AgentMessage;
-export declare class UserContextPlanner {
-    private readonly retriever;
-    plan(params: {
-        sessionKey: string;
-        workspaceId: string;
-        projectId?: string;
-        channel?: string;
-        turnId: string;
-        query: string;
-        userMessage: AgentMessage;
-        excludedRecordIds?: string[];
-        allocation?: UserContextPlan['allocation'];
-    }): UserContextPlan;
-}