dsh-mnemon-source-memory-spaces 0.5.14 → 0.5.15

package/lib/index.js

@@ -348,6 +348,8 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 		let normalizedService = this.providerCatalog.normalizeService(providerId, service);
 		const seen = /* @__PURE__ */ new Set();
 		const existing = this.spaces.filter((body) => body.providerId === providerId);
+		const existingByExternalId = /* @__PURE__ */ new Map();
+		for (const body of existing) if (!existingByExternalId.has(body.externalId)) existingByExternalId.set(body.externalId, body);
 		const reservedIds = new Set(this.spaces.filter((body) => body.providerId !== providerId).map((body) => body.id));
 		const timestamp = this.now().toISOString();
 		const projections = discovered.map((candidate) => {
@@ -359,7 +361,7 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 				...normalizedService,
 				...connection
 			});
-			const previous = existing.find((body) => body.externalId === externalId);
+			const previous = existingByExternalId.get(externalId);
 			let id = previous?.id ?? validateMemorySpaceId(`${providerId}-${createHash("sha256").update(externalId).digest("hex").slice(0, 24)}`);
 			let suffix = 1;
 			while (reservedIds.has(id)) {
@@ -756,9 +758,10 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 		const timestamp = this.now().toISOString();
 		const legacyActive = this.runner.effectiveStore();
 		let changed = false;
+		const knownIds = new Set(this.spaces.map((body) => body.id));
 		for (const entry of readdirSync(this.directory, { withFileTypes: true })) {
 			if (!entry.isDirectory() || !ID_PATTERN.test(entry.name) || !existsSync(join(this.directory, entry.name, "mnemon.db"))) continue;
-			if (this.spaces.some((body) => body.id === entry.name)) continue;
+			if (knownIds.has(entry.name)) continue;
 			this.spaces.push({
 				id: entry.name,
 				name: entry.name,
@@ -768,6 +771,7 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 				createdAt: timestamp,
 				updatedAt: timestamp
 			});
+			knownIds.add(entry.name);
 			changed = true;
 		}
 		if (changed) this.save();
@@ -1797,22 +1801,36 @@ var MemorySpacesService = class {
 		}
 		const { hints, quality } = evaluation;
 		const selected = recoveryPlan === void 0 ? quality.selected : prioritizeRecoveryEvidence(quality.selected, recoveryPlan);
-		const qualityStats = (memoryBodyId) => {
-			const evaluated = quality.evaluated.filter((candidate) => candidate.candidate.memoryBodyId === memoryBodyId);
-			const selected = quality.selected.filter((candidate) => candidate.candidate.memoryBodyId === memoryBodyId);
-			return {
-				policyId: quality.policyId,
-				...quality.fallbackFrom === void 0 ? {} : { fallbackFrom: quality.fallbackFrom },
-				fetched: evaluated.length,
-				retained: evaluated.filter((candidate) => candidate.decision.action === "keep").length,
-				selected: selected.length,
-				droppedLowScore: evaluated.filter((candidate) => candidate.decision.action === "drop" && candidate.decision.reason === "low-score").length,
-				droppedNonPositiveScore: evaluated.filter((candidate) => candidate.decision.action === "drop" && candidate.decision.reason === "non-positive-score").length,
-				droppedInvalidScore: evaluated.filter((candidate) => candidate.decision.action === "drop" && candidate.decision.reason === "invalid-score").length,
-				unscored: evaluated.filter((candidate) => candidate.decision.reason === "unscored").length,
-				unscaled: evaluated.filter((candidate) => candidate.decision.reason === "unscaled-score").length
-			};
-		};
+		const qualityStats = /* @__PURE__ */ new Map();
+		for (const { body } of batches) qualityStats.set(body.id, {
+			policyId: quality.policyId,
+			...quality.fallbackFrom === void 0 ? {} : { fallbackFrom: quality.fallbackFrom },
+			fetched: 0,
+			retained: 0,
+			selected: 0,
+			droppedLowScore: 0,
+			droppedNonPositiveScore: 0,
+			droppedInvalidScore: 0,
+			unscored: 0,
+			unscaled: 0
+		});
+		for (const { candidate, decision } of quality.evaluated) {
+			const stats = qualityStats.get(candidate.memoryBodyId);
+			if (stats === void 0) continue;
+			stats.fetched += 1;
+			if (decision.action === "keep") stats.retained += 1;
+			if (decision.action === "drop") {
+				if (decision.reason === "low-score") stats.droppedLowScore += 1;
+				if (decision.reason === "non-positive-score") stats.droppedNonPositiveScore += 1;
+				if (decision.reason === "invalid-score") stats.droppedInvalidScore += 1;
+			}
+			if (decision.reason === "unscored") stats.unscored += 1;
+			if (decision.reason === "unscaled-score") stats.unscaled += 1;
+		}
+		for (const { candidate } of quality.selected) {
+			const stats = qualityStats.get(candidate.memoryBodyId);
+			if (stats !== void 0) stats.selected += 1;
+		}
 		return {
 			query,
 			mode,
@@ -1822,7 +1840,7 @@ var MemorySpacesService = class {
 				...decision.normalizedScore === void 0 ? {} : { normalizedScore: decision.normalizedScore }
 			})),
 			sources: batches.map((batch) => {
-				const stats = qualityStats(batch.body.id);
+				const stats = qualityStats.get(batch.body.id);
 				if (batch.source.status === "unavailable" || batch.source.status === "unsupported") return {
 					...batch.source,
 					quality: stats
@@ -2044,13 +2062,21 @@ var MemorySpacesService = class {
 	*/
 	async rememberMany(requests, signal) {
 		this.assertWritable();
-		const prepared = requests.map((request) => this.prepareRemember(request));
+		const destinations = /* @__PURE__ */ new Map();
+		const prepared = requests.map((request) => this.prepareRemember(request, destinations));
 		const results = new Array(prepared.length);
 		const groups = /* @__PURE__ */ new Map();
-		for (const [index, entry] of prepared.entries()) groups.set(entry.body.id, [...groups.get(entry.body.id) ?? [], {
-			...entry,
-			index
-		}]);
+		for (const [index, entry] of prepared.entries()) {
+			const group = groups.get(entry.body.id);
+			if (group === void 0) groups.set(entry.body.id, [{
+				...entry,
+				index
+			}]);
+			else group.push({
+				...entry,
+				index
+			});
+		}
 		for (const group of groups.values()) {
 			const body = group[0].body;
 			const provider = this.providerFor(body);
@@ -2066,8 +2092,9 @@ var MemorySpacesService = class {
 					providerChanged ||= mutationResultCommitted(result);
 				}
 			}
+			const batched = new Set(batch);
 			for (const entry of group) {
-				if (batch.includes(entry)) continue;
+				if (batched.has(entry)) continue;
 				const result = await provider.remember(body, entry.request, signal);
 				results[entry.index] = this.annotateResult(result, body);
 				providerChanged ||= mutationResultCommitted(result);
@@ -2273,10 +2300,14 @@ var MemorySpacesService = class {
 		return provider;
 	}
 	readSpaces(ids) {
-		const active = this.memorySpaces.active();
-		if (ids === void 0 || ids.length === 0) return active;
-		return [...new Set(ids.map((id) => id.trim()).filter((id) => id !== ""))].map((id) => {
-			const body = this.memorySpaces.get(id);
+		if (ids === void 0 || ids.length === 0) return this.memorySpaces.active();
+		const requested = [...new Set(ids.map((id) => id.trim()).filter((id) => id !== ""))];
+		const available = /* @__PURE__ */ new Map();
+		for (const body of this.memorySpaces.list()) if (!available.has(body.id)) available.set(body.id, body);
+		return requested.map((id) => {
+			const normalized = validateMemorySpaceId(id);
+			const body = available.get(normalized);
+			if (body === void 0) throw new Error(`unknown memory space: ${normalized}`);
 			if (!body.active) throw new Error(`memory space is not active for reading: ${id}`);
 			if (!this.isNativeSpace(body) && !this.memorySpaces.providerServiceEnabled(body.provider.id)) throw new Error(`${body.provider.label} is disabled on the dsh-mnemon page under Plugins`);
 			return body;
@@ -2303,8 +2334,10 @@ var MemorySpacesService = class {
 		if (active.length !== 1) throw new Error("memoryBodyId is required when the number of active memory spaces is not exactly one");
 		return active[0];
 	}
-	prepareRemember(request) {
-		const body = this.writeSpace(request.memoryBodyId);
+	prepareRemember(request, destinations) {
+		const key = request.memoryBodyId?.trim() ?? "";
+		const body = destinations?.get(key) ?? this.writeSpace(request.memoryBodyId);
+		destinations?.set(key, body);
 		const content = required(request.content, "content", 8192);
 		const importance = memoryInputInteger(request.importance, 3, 1, 5);
 		const category = allowed(request.category, CATEGORIES$1, "category") ?? "general";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mnemon-source-memory-spaces",
-  "version": "0.5.14",
+  "version": "0.5.15",
   "description": "Memory Spaces Source and its private Provider SDK.",
   "license": "MIT",
   "type": "module",
@@ -65,10 +65,10 @@
     "@types/node": "^22.0.0",
     "@types/react": "^18.3.0",
     "@types/react-dom": "^18.3.0",
-    "dsh-mnemon": "^0.5.21",
+    "dsh-mnemon": "^0.5.23",
     "dsh-mnemon-provider-byterover": "^0.5.5",
     "dsh-mnemon-provider-hindsight": "^0.5.5",
-    "dsh-mnemon-provider-holographic": "^0.5.5",
+    "dsh-mnemon-provider-holographic": "^0.5.6",
     "dsh-mnemon-provider-honcho": "^0.5.5",
     "dsh-mnemon-provider-mem0": "^0.5.5",
     "dsh-mnemon-provider-mnemon-native": "^0.5.8",