@snoai/memory 0.0.0-stage → 1.0.1

package/dist/resolver-Dy-hnjCR.js

@@ -0,0 +1,103 @@
+import { isSupportedLocale } from "./internal/engine/i18n/locales.js";
+import { createLogger } from "@snoai/utils/logger";
+import { LRUCache } from "lru-cache";
+import { eld } from "eld/medium";
+//#region src/engine/i18n/detector.ts
+const log = createLogger("sno-station-mem:i18n-detector");
+const HAS_HAN = /[一-鿿]/u;
+const HANT_DISTINCT_CHARS = "說講識讀譯長寫關類體聖貝謊議證讓訊為";
+const HANS_DISTINCT_CHARS = "说讲识读译长写关类体圣贝谎议证让讯为";
+const HANT_DISTINCT_RE = new RegExp(`[${HANT_DISTINCT_CHARS}]`, "gu");
+const HANS_DISTINCT_RE = new RegExp(`[${HANS_DISTINCT_CHARS}]`, "gu");
+const DETECTOR_RETRY_AFTER_MS = 6e4;
+let detectorReady = false;
+let detectorBroken = false;
+let detectorRetryAtMs = 0;
+function markDetectorBroken(error, reasonCode) {
+	detectorReady = false;
+	detectorBroken = true;
+	detectorRetryAtMs = Date.now() + DETECTOR_RETRY_AFTER_MS;
+	log.warn("Language detector temporarily unavailable", {
+		error,
+		reason_code: reasonCode,
+		retryAfterMs: DETECTOR_RETRY_AFTER_MS
+	}, {
+		event_name: "language.detector.unavailable",
+		file: "packages/memory/src/engine/i18n/detector.ts",
+		function: "markDetectorBroken",
+		site_id: "language.detector.unavailable"
+	});
+}
+function ensureDetector() {
+	if (detectorBroken) {
+		if (Date.now() < detectorRetryAtMs) return false;
+		detectorBroken = false;
+		detectorRetryAtMs = 0;
+	}
+	if (detectorReady) return true;
+	try {
+		eld.info();
+		detectorReady = true;
+		return true;
+	} catch (error) {
+		markDetectorBroken(error, "detector_initialization_failed");
+		return false;
+	}
+}
+function refineChinese(text) {
+	if ((text.match(HANT_DISTINCT_RE)?.length ?? 0) > (text.match(HANS_DISTINCT_RE)?.length ?? 0)) return "zh-Hant";
+	return "zh";
+}
+function detectLocale(text) {
+	if (!text || text.length < 4) return void 0;
+	if (!ensureDetector()) return void 0;
+	try {
+		const lang = eld.detect(text)?.language;
+		if (!lang) return void 0;
+		if (lang === "zh") {
+			if (HAS_HAN.test(text)) return refineChinese(text);
+			return "zh";
+		}
+		if (isSupportedLocale(lang)) return lang;
+		return;
+	} catch (error) {
+		markDetectorBroken(error, "detector_detection_failed");
+		return;
+	}
+}
+//#endregion
+//#region src/engine/i18n/resolver.ts
+const SHORT_TEXT_BYPASS_CHARS = 8;
+const SESSION_ID_MAX_CHARS = 256;
+const sessionCache = new LRUCache({
+	max: 1e3,
+	ttl: 216e5
+});
+function normalizeSessionId(sessionId) {
+	const trimmed = sessionId?.trim();
+	if (!trimmed) return void 0;
+	if (trimmed.length > SESSION_ID_MAX_CHARS) return void 0;
+	if (hasControlCharacter(trimmed)) return void 0;
+	return trimmed;
+}
+function hasControlCharacter(value) {
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (code <= 31 || code === 127) return true;
+	}
+	return false;
+}
+function resolveLocale({ text, sessionId, explicitLocale }) {
+	if (explicitLocale && isSupportedLocale(explicitLocale)) return explicitLocale;
+	if (!text || text.trim().length === 0) return "en";
+	const cacheKey = normalizeSessionId(sessionId);
+	const cached = cacheKey ? sessionCache.get(cacheKey) : void 0;
+	if (cached) return cached.locale;
+	if (!text || text.trim().length < SHORT_TEXT_BYPASS_CHARS) return "en";
+	const detected = detectLocale(text);
+	if (!detected) return "en";
+	if (cacheKey) sessionCache.set(cacheKey, { locale: detected });
+	return detected;
+}
+//#endregion
+export { resolveLocale as t };

package/dist/results-C3ZLroMb.js

@@ -0,0 +1,140 @@
+import { MEMORY_CATEGORIES } from "./internal/engine/shared/types.js";
+import { n as DEGRADED_REASONS } from "./error-D-wb-rZw.js";
+import { z } from "zod";
+//#region src/contract/results.ts
+const memoryEntrySchema = z.strictObject({
+	id: z.string().min(1),
+	factId: z.string().optional(),
+	text: z.string(),
+	category: z.enum(MEMORY_CATEGORIES),
+	projectId: z.string(),
+	importance: z.number().finite(),
+	timestamp: z.number().finite(),
+	timezone: z.string(),
+	metadata: z.string(),
+	contentHash: z.string(),
+	lane: z.enum([
+		"active",
+		"parked",
+		"quarantined"
+	]),
+	rawCandidateJson: z.string().optional(),
+	dispositionReason: z.string().optional(),
+	dispositionedAt: z.number().finite().optional()
+});
+const nativeHitSchema = z.strictObject({
+	path: z.string(),
+	startLine: z.number().int(),
+	endLine: z.number().int(),
+	score: z.number().finite(),
+	vectorScore: z.number().finite().optional(),
+	textScore: z.number().finite().optional(),
+	snippet: z.string(),
+	source: z.enum(["memory", "sessions"]),
+	citation: z.string().optional()
+});
+const score = z.strictObject({ score: z.number().finite() });
+const rankedScore = score.extend({ rank: z.number().int() });
+const retrievalResultSchema = z.strictObject({
+	entry: memoryEntrySchema,
+	score: z.number().finite(),
+	eventIdentity: z.string().optional(),
+	scopeRowCount: z.number().int().nonnegative().optional(),
+	aggregationIncomplete: z.boolean().optional(),
+	sources: z.strictObject({
+		vector: rankedScore.optional(),
+		bm25: rankedScore.optional(),
+		fused: score.optional(),
+		reranked: score.optional()
+	}),
+	chunkId: z.string().optional(),
+	chunkIndex: z.number().int().optional(),
+	bestChunkScore: z.number().finite().optional(),
+	snippet: z.string().optional(),
+	recallGroupKey: z.string().optional(),
+	denseScore: z.number().finite().optional(),
+	bm25Score: z.number().finite().optional(),
+	fusedScore: z.number().finite().optional(),
+	rerankScore: z.number().finite().optional(),
+	mmrScore: z.number().finite().optional()
+});
+const toolResponseSchema = z.strictObject({
+	isError: z.boolean().optional(),
+	content: z.array(z.strictObject({
+		type: z.literal("text"),
+		text: z.string()
+	})),
+	details: z.record(z.string(), z.json())
+});
+const inspectDataSchema = z.discriminatedUnion("op", [
+	z.strictObject({
+		op: z.literal("storage"),
+		dimension: z.number().int().positive().nullable(),
+		failed: z.boolean(),
+		reason: z.string().optional()
+	}),
+	z.strictObject({
+		op: z.literal("stats"),
+		total: z.number().int().nonnegative(),
+		projectBreakdown: z.record(z.string(), z.number().int().nonnegative()),
+		categoryBreakdown: z.record(z.string(), z.number().int().nonnegative())
+	}),
+	z.strictObject({
+		op: z.enum(["list", "listReflection"]),
+		project: z.string().min(1),
+		entries: z.array(memoryEntrySchema)
+	}),
+	z.strictObject({
+		op: z.literal("get"),
+		entry: memoryEntrySchema.nullable(),
+		file: z.strictObject({
+			text: z.string(),
+			path: z.string(),
+			truncated: z.boolean().optional(),
+			from: z.number().int().optional(),
+			lines: z.number().int().optional(),
+			nextFrom: z.number().int().optional()
+		}).optional()
+	})
+]);
+function resultSchema(shape) {
+	return z.discriminatedUnion("degraded", [z.strictObject({
+		...shape,
+		degraded: z.literal(false)
+	}), z.strictObject({
+		...shape,
+		degraded: z.literal(true),
+		reason: z.enum(DEGRADED_REASONS),
+		error: z.string().optional()
+	})]);
+}
+const outputSchemas = {
+	init: resultSchema({
+		principal: z.string().min(1),
+		skinId: z.string().min(1)
+	}),
+	hostEvent: resultSchema({ accepted: z.boolean() }),
+	getRecall: resultSchema({
+		recallId: z.string(),
+		contextText: z.string(),
+		hits: z.array(retrievalResultSchema).optional(),
+		memoryIds: z.array(z.string().min(1)).optional(),
+		toolResult: toolResponseSchema.optional(),
+		nativeHits: z.array(nativeHitSchema).optional(),
+		unavailable: z.string().optional()
+	}),
+	capture: resultSchema({
+		turnId: z.string().min(1),
+		committed: z.boolean(),
+		accepted: z.boolean().optional(),
+		skipped: z.literal(true).optional(),
+		partial: z.literal(true).optional()
+	}),
+	mutate: resultSchema({ result: toolResponseSchema }),
+	inspect: resultSchema({ result: inspectDataSchema }),
+	recordUsage: resultSchema({ accepted: z.boolean() }),
+	onSessionEnd: resultSchema({ completed: z.boolean() }),
+	staticBlock: resultSchema({ contextText: z.string() })
+};
+//#endregion
+export { toolResponseSchema as a, retrievalResultSchema as i, memoryEntrySchema as n, outputSchemas as r, inspectDataSchema as t };

package/dist/retrieval-gate-Bx2Zg7jD.d.ts

@@ -0,0 +1,31 @@
+//#region src/engine/retrieval/retrieval-gate.d.ts
+/** @file retrieval-gate.ts
+ * @purpose Decides whether a query needs memory retrieval at all (skip vs proceed).
+ * @boundary Intent analysis, temporal classification, and retrieval configuration.
+ * @see intent-analyzer.ts, memory-temporality-classifier.ts, retriever.ts.
+ */
+/**
+ * Retrieval Gate
+ * Determines whether a query needs memory retrieval at all.
+ * Skips retrieval for greetings, commands, simple instructions, and system messages.
+ * Saves embedding API calls and reduces noise injection.
+ */
+/**
+ * Strip SnoStationMem metadata headers, cron wrappers, and timestamp prefixes
+ * so that the raw user intent is what gets evaluated by skip/force patterns.
+ */
+declare function normalizeQuery(raw: string): string;
+/**
+ * Decide whether a query is too short to search on. Length only.
+ *
+ * There is deliberately NO pattern list here. Until 2026-08-21 this function also read 118 skip
+ * and force-retrieve regexes across nine locale bundles, and a match on a negative one meant the
+ * turn was never searched at all — a keyword deciding the control flow, which is the shape this
+ * repository forbids. Retrieval is a local SQLite plus local-embedding search; the cost argument
+ * that justified a gate does not hold, and whether a result is relevant belongs to scoring.
+ *
+ * @param minLength - Override minimum length threshold (for autoRecallMinLength support).
+ */
+declare function shouldSkipRetrieval(query: string, minLength?: number): boolean;
+//#endregion
+export { shouldSkipRetrieval as n, normalizeQuery as t };