@snoai/memory 0.0.0-stage → 1.0.0

package/dist/rem-batch-executor-bc0IFlp2.js

@@ -0,0 +1,2 @@
+import { o as runRemProductionOrderedWave } from "./rem-batch-executor-Cbm5gfSe.js";
+export { runRemProductionOrderedWave };

package/dist/rem-consumer-retrieval-CRpvG8KS.js

@@ -0,0 +1,246 @@
+import { DEFAULT_RECALL_TOKEN_BUDGET, MIN_RECALL_TOKEN_BUDGET } from "./internal/config/index.js";
+import { o as readMemorySourceOrderOrOldest, r as compareMemorySourceOrder } from "./memory-source-order-BtrIxaIt.js";
+//#region src/engine/retrieval/recall-token-packer.ts
+/** @file recall-token-packer.ts
+* @purpose Packs recall rows into a character-estimated token budget without changing rank order.
+* @boundary Pure row selection and budget accounting; no retrieval or rendering.
+*/
+function estimateRecallRowTokens(chars) {
+	return Math.ceil(chars / 4);
+}
+function packRecallRows(rows, rowText, tokenBudget = DEFAULT_RECALL_TOKEN_BUDGET, groupKey) {
+	if (!Number.isFinite(tokenBudget) || tokenBudget < 5e3) throw new RangeError(`Recall token budget must be at least ${MIN_RECALL_TOKEN_BUDGET}.`);
+	const packed = [];
+	let budgetUsed = 0;
+	let droppedCount = 0;
+	const droppedGroups = /* @__PURE__ */ new Set();
+	for (const row of rows) {
+		const key = groupKey?.(row);
+		if (key !== void 0 && droppedGroups.has(key)) {
+			droppedCount += 1;
+			continue;
+		}
+		const rowTokens = estimateRecallRowTokens(rowText(row).length);
+		if (rowTokens > tokenBudget - budgetUsed) {
+			droppedCount += 1;
+			if (key !== void 0) droppedGroups.add(key);
+			continue;
+		}
+		packed.push(row);
+		budgetUsed += rowTokens;
+	}
+	return {
+		rows: packed,
+		budget_used: budgetUsed,
+		dropped_count: droppedCount
+	};
+}
+//#endregion
+//#region src/engine/retrieval/rem-consumer-retrieval.ts
+const GROUP_CRUD_MAINTENANCE_RECEIPT = "group-crud-maintenance-v1";
+function parseRecallMetadata(metadata) {
+	if (typeof metadata === "string") try {
+		return parseRecallMetadata(JSON.parse(metadata));
+	} catch {
+		return;
+	}
+	if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) return;
+	return metadata;
+}
+function isOpenRecallMetadata(metadata) {
+	return typeof parseRecallMetadata(metadata)?.["superseded_by"] !== "string";
+}
+function recallGroupKey(row) {
+	return JSON.stringify([
+		row.projectId,
+		row.category,
+		row.subject,
+		row.attribute
+	]);
+}
+function hasGroupCrudMaintenanceReceipt(retriever) {
+	return retriever.store.sqlite.prepare("SELECT 1 FROM nodix_todo_migration_receipts WHERE migration_id = ? LIMIT 1").get(GROUP_CRUD_MAINTENANCE_RECEIPT) !== void 0;
+}
+function readRetrievedGroupRows(retriever, rows) {
+	return retriever.store.sqlite.prepare(`
+			SELECT id, project_id AS projectId, category, subject, attribute, metadata
+			FROM nodix_memories
+			WHERE id IN (SELECT value FROM json_each(?))
+				AND attribute IS NOT NULL
+				AND category != 'episodic'
+		`).all(JSON.stringify(rows.map((row) => row.entry.id)));
+}
+function readOpenGroupRows(retriever, groups, visibility) {
+	const identities = groups.map((group) => [
+		group.projectId,
+		group.subject,
+		group.attribute,
+		group.category
+	]);
+	const params = [JSON.stringify(identities)];
+	let sql = `
+			WITH wanted AS (
+				SELECT
+					json_extract(value, '$[0]') AS project_id,
+					json_extract(value, '$[1]') AS subject,
+					json_extract(value, '$[2]') AS attribute,
+					json_extract(value, '$[3]') AS category
+				FROM json_each(?)
+			)
+			SELECT DISTINCT
+				m.id,
+				m.project_id AS projectId,
+				m.category,
+				m.subject,
+				m.attribute,
+				m.metadata
+			FROM nodix_memories m
+			JOIN wanted w
+				ON m.project_id = w.project_id
+				AND m.subject = w.subject
+				AND m.attribute IS w.attribute
+				AND m.category = w.category
+			WHERE m.lane = 'active'
+		`;
+	if (visibility.category !== void 0) {
+		sql += " AND m.category = ?";
+		params.push(visibility.category);
+	}
+	if (!visibility.includeRefused) sql += " AND m.disposition_reason IS NULL";
+	sql += " AND (NOT json_valid(m.metadata) OR json_extract(m.metadata, '$.invalidated_at') IS NULL OR json_extract(m.metadata, '$.invalidated_at') > ?)";
+	params.push(visibility.excludeInvalidatedBefore);
+	return retriever.store.sqlite.prepare(sql).all(...params).filter((row) => isOpenRecallMetadata(row.metadata));
+}
+function groupRowsNewestFirst(rows) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const key = recallGroupKey(row);
+		const group = grouped.get(key) ?? [];
+		group.push(row);
+		grouped.set(key, group);
+	}
+	for (const group of grouped.values()) group.sort((left, right) => compareMemorySourceOrder(readMemorySourceOrderOrOldest(right.metadata), readMemorySourceOrderOrOldest(left.metadata)) || right.id.localeCompare(left.id));
+	return grouped;
+}
+function retrievalResultForGroupRow(retriever, row, anchor, retrievedById) {
+	const retrieved = retrievedById.get(row.id);
+	if (retrieved) return retrieved;
+	const entry = retriever.store.getById(row.id);
+	if (!entry) return void 0;
+	return {
+		entry,
+		score: anchor.score,
+		sources: anchor.sources
+	};
+}
+function orderExpandedRecallRows(rows, hitById, resultsByGroup) {
+	const served = [];
+	const servedIds = /* @__PURE__ */ new Set();
+	const append = (row) => {
+		if (servedIds.has(row.entry.id)) return;
+		servedIds.add(row.entry.id);
+		served.push(row);
+	};
+	const expandedGroups = /* @__PURE__ */ new Set();
+	for (const row of rows) {
+		const hit = hitById.get(row.entry.id);
+		if (!hit) {
+			append(row);
+			continue;
+		}
+		const key = recallGroupKey(hit);
+		if (expandedGroups.has(key)) continue;
+		expandedGroups.add(key);
+		for (const member of resultsByGroup.get(key) ?? []) append(member);
+	}
+	return served;
+}
+function serveRecallGroups(retriever, rows, visibility) {
+	const hitRows = readRetrievedGroupRows(retriever, rows).filter((row) => row.subject !== null && isOpenRecallMetadata(row.metadata));
+	const hitById = new Map(hitRows.map((row) => [row.id, row]));
+	const anchors = /* @__PURE__ */ new Map();
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const hit = hitById.get(row.entry.id);
+		if (!hit) continue;
+		const key = recallGroupKey(hit);
+		if (anchors.has(key)) continue;
+		anchors.set(key, row);
+		groups.set(key, hit);
+	}
+	if (groups.size === 0) return [...rows];
+	const groupRows = groupRowsNewestFirst(readOpenGroupRows(retriever, [...groups.values()], visibility));
+	const retrievedById = new Map(rows.map((row) => [row.entry.id, row]));
+	const resultsByGroup = /* @__PURE__ */ new Map();
+	for (const [key, members] of groupRows) {
+		const anchor = anchors.get(key);
+		if (!anchor) continue;
+		const results = members.flatMap((member) => {
+			const result = retrievalResultForGroupRow(retriever, member, anchor, retrievedById);
+			return result ? [{
+				...result,
+				recallGroupKey: key
+			}] : [];
+		});
+		resultsByGroup.set(key, results);
+	}
+	return orderExpandedRecallRows(rows, hitById, resultsByGroup);
+}
+async function retrieveForAutoRecall(retriever, input) {
+	const retrieved = await retriever.retrieve({
+		query: input.query,
+		limit: input.limit,
+		minScore: input.minScore,
+		scopeFilter: input.scopeFilter,
+		...input.signal === void 0 ? {} : { signal: input.signal },
+		...input.sessionId === void 0 ? {} : { sessionId: input.sessionId },
+		source: "auto-recall",
+		facetPolicy: "current-only",
+		includeRefused: true,
+		excludeInvalidatedBefore: input.nowMs,
+		excludeSuperseded: true
+	});
+	const openRows = retrieved.filter((row) => isOpenRecallMetadata(row.entry.metadata));
+	if (input.diagnostics) {
+		input.diagnostics.retired_closed_removed_count = retrieved.length - openRows.length;
+		input.diagnostics.post_filter_input_count = retrieved.length;
+		input.diagnostics.post_filter_output_count = openRows.length;
+	}
+	return openRows;
+}
+async function retrieveForMemoryRecallOrEval(retriever, input) {
+	const retrieved = await retriever.retrieve({
+		query: input.query,
+		signal: input.signal,
+		limit: input.limit,
+		scopeFilter: input.scopeFilter,
+		...input.category === void 0 ? {} : { category: input.category },
+		...input.includeRefused === void 0 ? {} : { includeRefused: input.includeRefused },
+		...input.aggregation === void 0 ? {} : { aggregation: input.aggregation },
+		...input.explicitLocale === void 0 ? {} : { explicitLocale: input.explicitLocale },
+		source: "manual",
+		includeRetired: input.facetPolicy !== "current-only",
+		...input.facetPolicy === void 0 ? {} : { facetPolicy: input.facetPolicy },
+		allowAggregation: true,
+		excludeInvalidatedBefore: input.nowMs,
+		excludeSuperseded: input.facetPolicy === "current-only"
+	});
+	const openRows = input.facetPolicy === "current-only" ? retrieved.filter((row) => isOpenRecallMetadata(row.entry.metadata)) : retrieved;
+	if (input.diagnostics) {
+		input.diagnostics.retired_closed_removed_count = retrieved.length - openRows.length;
+		input.diagnostics.post_filter_input_count = retrieved.length;
+		input.diagnostics.post_filter_output_count = openRows.length;
+	}
+	if (input.aggregation !== void 0) return openRows;
+	if (!hasGroupCrudMaintenanceReceipt(retriever)) return openRows;
+	return serveRecallGroups(retriever, openRows, {
+		...input.category === void 0 ? {} : { category: input.category },
+		includeRefused: input.includeRefused ?? true,
+		excludeInvalidatedBefore: input.nowMs
+	});
+}
+function packManualRecallRows(rows, tokenBudget) {
+	return packRecallRows(rows, (row) => row.snippet?.trim() || row.entry.text, tokenBudget, (row) => row.recallGroupKey);
+}
+//#endregion
+export { retrieveForMemoryRecallOrEval as i, packManualRecallRows as n, retrieveForAutoRecall as r, isOpenRecallMetadata as t };