@mulmoclaude/core 0.25.0 → 0.26.0

package/dist/collection-watchers/index.d.ts

@@ -1,4 +1,4 @@
 export { configureCollectionWatchers, resetCollectionWatchersConfig, type CollectionNotificationAdapter, type CollectionWatcherLogger, type CompletionPriority, } from './config.js';
 export { reconcileItem, reconcileAllItems, sweepStaleActiveEntries, clearItemNotification, resolveDisplayLabel, itemIsDone, _resetReconcilerLocksForTesting, } from './reconciler.js';
 export { evalNow } from './clock.js';
-export { startCollectionWatchers, stopCollectionWatchers, _syncWatchersForTesting, _tickTimeTriggersForTesting, _scheduleItemReconcileForTesting, type CollectionWatcherOptions, } from './watcher.js';
+export { startCollectionWatchers, stopCollectionWatchers, _syncWatchersForTesting, _tickTimeTriggersForTesting, _scheduleItemReconcileForTesting, _scheduleStorageReconcileForTesting, type CollectionWatcherOptions, } from './watcher.js';

package/dist/collection-watchers/index.js

@@ -1,11 +1,11 @@
-import { S as itemIsDone, j as whenMatches } from "../promptSafety-Boz5qOs-.js";
+import { M as fieldText, S as itemIsDone, j as whenMatches } from "../promptSafety-B5KPkaNY.js";
 import "../collection/index.js";
-import { I as publishCollectionChange, _ as readItem, n as discoverCollections, p as listItems, r as loadCollection } from "../discovery-3K_Wtkvn.js";
-import { d as isTriggerDue, f as maybeSpawnSuccessor } from "../server-DZH7OjOD.js";
+import { W as itemFilePath, n as discoverCollections, r as loadCollection, tt as publishCollectionChange, u as storeFor } from "../discovery-QUi_7aNG.js";
+import { d as isTriggerDue, f as maybeSpawnSuccessor } from "../server-CNLZZONa.js";
 import { d as publish, m as updateForPlugin, n as clear, s as listAll } from "../notifier-ChpY0XrY.js";
 import path from "node:path";
 import { watch } from "node:fs";
-import { mkdir } from "node:fs/promises";
+import { access, mkdir } from "node:fs/promises";
 //#region src/collection-watchers/config.ts
 var NOOP_LOG = {
 	info: () => {},
@@ -73,9 +73,7 @@ function parseCompletionLegacyId(legacyId) {
 function resolveDisplayLabel(schema, item, itemId) {
 	const { displayField } = schema;
 	if (!displayField) return itemId;
-	const raw = item[displayField];
-	if (raw === void 0 || raw === null) return itemId;
-	const label = String(raw).trim();
+	const label = fieldText(item[displayField]).trim();
 	return label.length > 0 ? label : itemId;
 }
 /** Every active bell entry whose key matches this (slug, itemId).
@@ -182,24 +180,26 @@ async function clearItemNotification(slug, itemId) {
 		});
 	}
 }
-/** Reconcile one item to the desired bell state. Re-reads the record from
-*  disk so the decision is grounded in current truth, not in the event
-*  payload. Safe to call when the file is missing (delete path).
+/** Reconcile one item to the desired bell state. Re-reads the record
+*  through the collection's STORE (file, sqlite, …) so the decision is
+*  grounded in current truth, not in the event payload. Safe to call when
+*  the record is missing (delete path).
 *
-*  `ioOpts` flows into `readItem`'s workspace-containment check —
+*  `ioOpts` flows into the store's workspace-containment checks —
 *  production callers (the watcher) pass nothing; tests pass
 *  `{ workspaceRoot: <tmpdir> }` so the check accepts a fixture dataDir. */
-async function reconcileItem(slug, schema, dataDir, itemId, ioOpts = {}, now = evalNow()) {
+async function reconcileItem(collection, itemId, ioOpts = {}, now = evalNow()) {
+	const { slug, schema } = collection;
 	if (!schema.completionField) {
 		await clearItemNotification(slug, itemId);
 		return;
 	}
-	const item = await readItem(dataDir, itemId, ioOpts);
+	const item = await storeFor(collection, ioOpts).read(itemId);
 	if (item === null) {
 		await clearItemNotification(slug, itemId);
 		return;
 	}
-	await maybeSpawnSuccessor(slug, schema, dataDir, item, itemId, ioOpts);
+	await maybeSpawnSuccessor(collection, item, itemId, ioOpts);
 	if (itemIsDone(schema, item)) {
 		await clearItemNotification(slug, itemId);
 		return;
@@ -223,19 +223,20 @@ async function reconcileItem(slug, schema, dataDir, itemId, ioOpts = {}, now = e
 	}
 	await ensureItemNotification(slug, schema, itemId, resolveDisplayLabel(schema, item, itemId), notifyPriorityForItem(schema, item));
 }
-/** Boot-time reconcile: walk every record under `dataDir` once and
-*  reconcile it. Catches up changes that happened while the server was
-*  down. Deleted items are covered by `sweepStaleActiveEntries`, not this
-*  function (it only sees files that exist). */
-async function reconcileAllItems(slug, schema, dataDir, ioOpts = {}, now = evalNow()) {
+/** Boot-time reconcile: walk every record of the collection once (through
+*  its store) and reconcile it. Catches up changes that happened while the
+*  server was down. Deleted items are covered by
+*  `sweepStaleActiveEntries`, not this function (it only sees records
+*  that exist). */
+async function reconcileAllItems(collection, ioOpts = {}, now = evalNow()) {
+	const { slug, schema } = collection;
 	if (!schema.completionField) return;
 	let items;
 	try {
-		items = await listItems(dataDir, ioOpts);
+		items = await storeFor(collection, ioOpts).list();
 	} catch (err) {
 		log().warn("reconcile list failed", {
 			slug,
-			dataDir,
 			error: errMsg(err)
 		});
 		return;
@@ -244,7 +245,7 @@ async function reconcileAllItems(slug, schema, dataDir, ioOpts = {}, now = evalN
 	for (const item of items) {
 		const raw = item[primaryKey];
 		if (typeof raw !== "string" || raw.length === 0) continue;
-		await reconcileItem(slug, schema, dataDir, raw, ioOpts, now);
+		await reconcileItem(collection, raw, ioOpts, now);
 	}
 }
 /** Boot-time sweep over the active bell: drop any entries whose underlying
@@ -272,7 +273,7 @@ async function sweepStaleActiveEntries(opts = {}) {
 				await clear(entry.id);
 				continue;
 			}
-			const item = await readItem(collection.dataDir, itemId, opts);
+			const item = await storeFor(collection, opts).read(itemId);
 			if (item === null || itemIsDone(collection.schema, item) || !whenMatches(collection.schema.notifyWhen, item)) await clear(entry.id);
 		} catch (err) {
 			log().warn("sweep entry failed", {
@@ -304,6 +305,10 @@ var started = false;
 *  without threading through every signature. */
 var discoveryOpts = {};
 var itemSlots = /* @__PURE__ */ new Map();
+/** Per-slug single-flight for a storage (db-file) collection's full
+*  reconcile pass — a burst of db writes collapses to one pass + one
+*  trailing re-run, mirroring the per-item slots of the file watcher. */
+var storageSlots = /* @__PURE__ */ new Map();
 /** Trailing debounce per dataSource collection: an atomic file replace
 *  (Excel save, editor rename) surfaces as 2-3 fs events — collapse them
 *  into one change publish so live views refetch once. */
@@ -359,6 +364,7 @@ async function stopCollectionWatchers() {
 	} catch {}
 	watchers.clear();
 	itemSlots.clear();
+	storageSlots.clear();
 	for (const timer of dataSourceTimers.values()) clearTimeout(timer);
 	dataSourceTimers.clear();
 	discoveryOpts = {};
@@ -392,7 +398,7 @@ async function tickTimeTriggers(now = evalNow()) {
 		}
 		if (schema.dataSource !== void 0) continue;
 		if (!schema.triggerField && !schema.spawn) continue;
-		await reconcileAllItems(entry.slug, schema, entry.dataDir, discoveryOpts, now);
+		await reconcileAllItems(entry.collection, discoveryOpts, now);
 	}
 }
 /** Reconcile the watcher set against the currently-discovered
@@ -438,7 +444,7 @@ function storagePathChanged(previousJson, next) {
 	} catch {
 		return true;
 	}
-	return previous.dataSource?.path !== next.dataSource?.path || previous.dataPath !== next.dataPath;
+	return previous.dataSource?.path !== next.dataSource?.path || previous.dataPath !== next.dataPath || previous.storage?.path !== next.storage?.path;
 }
 /** Re-reconcile already-watched collections whose schema changed since
 *  the last tick. New collections fall through to `startNewWatchers`. */
@@ -463,6 +469,7 @@ async function reconcileChangedSchemas(collections) {
 			continue;
 		}
 		existing.schemaJson = nextJson;
+		existing.collection = collection;
 		if (collection.schema.dataSource !== void 0) {
 			log().info("dataSource watcher schema changed, publishing", { slug: collection.slug });
 			publishCollectionChange({
@@ -473,7 +480,7 @@ async function reconcileChangedSchemas(collections) {
 			continue;
 		}
 		log().info("watcher schema changed, re-reconciling", { slug: collection.slug });
-		await reconcileAllItems(collection.slug, collection.schema, collection.dataDir, discoveryOpts);
+		await reconcileAllItems(collection, discoveryOpts);
 		mutated = true;
 	}
 	return mutated;
@@ -483,7 +490,8 @@ async function startNewWatchers(collections) {
 	for (const collection of collections) {
 		if (watchers.has(collection.slug)) continue;
 		if (collection.schema.dataSource !== void 0) await startDataSourceWatcher(collection);
-		else await startWatcherFor(collection.slug, collection.schema, collection.dataDir);
+		else if (collection.schema.storage !== void 0) await startStorageWatcher(collection);
+		else await startWatcherFor(collection);
 		mutated = true;
 	}
 	return mutated;
@@ -529,7 +537,8 @@ async function startDataSourceWatcher(collection) {
 			slug: collection.slug,
 			dataDir: dir,
 			watcher,
-			schemaJson: JSON.stringify(collection.schema)
+			schemaJson: JSON.stringify(collection.schema),
+			collection
 		});
 		log().info("dataSource watcher started", {
 			slug: collection.slug,
@@ -542,10 +551,76 @@ async function startDataSourceWatcher(collection) {
 		});
 	}
 }
-async function startWatcherFor(slug, schema, dataDir) {
+/** Watch a `storage` collection's database file. One db file holds every
+*  record, so an event can't name WHICH record changed — each (debounced)
+*  event runs a full `reconcileAllItems` pass (bells / spawn) plus a
+*  change publish so views refetch after EXTERNAL edits too (host writes
+*  already publish their own change events; the extra ping is debounced
+*  and idempotent). Mounts on the parent dir, same as the dataSource
+*  watcher, so an atomic replace can't strand the watch. */
+async function startStorageWatcher(collection) {
+	const file = collection.storageFile;
+	if (file === void 0) return;
+	const dir = path.dirname(file);
+	const base = path.basename(file);
+	try {
+		await mkdir(dir, { recursive: true });
+		await reconcileAllItems(collection, discoveryOpts);
+		const watcher = watch(dir, { persistent: false }, (_eventType, rawFilename) => {
+			const filename = rawFilename === null ? null : String(rawFilename);
+			if (filename !== null && !filename.startsWith(base)) return;
+			scheduleStorageReconcile(collection.slug).catch((err) => {
+				log().warn("storage watcher reconcile failed", {
+					slug: collection.slug,
+					error: errMsg(err)
+				});
+			});
+		});
+		watcher.on("error", (err) => {
+			log().warn("storage watcher error", {
+				slug: collection.slug,
+				error: errMsg(err)
+			});
+		});
+		watchers.set(collection.slug, {
+			slug: collection.slug,
+			dataDir: dir,
+			watcher,
+			schemaJson: JSON.stringify(collection.schema),
+			collection
+		});
+		log().info("storage watcher started", {
+			slug: collection.slug,
+			file
+		});
+	} catch (err) {
+		log().warn("storage watcher start failed", {
+			slug: collection.slug,
+			error: errMsg(err)
+		});
+	}
+}
+function scheduleStorageReconcile(slug) {
+	return runSingleFlight(storageSlots, slug, async () => {
+		const collection = await loadCollection(slug, discoveryOpts);
+		if (!collection) return;
+		await reconcileAllItems(collection, discoveryOpts);
+		await sweepStaleActiveEntries(discoveryOpts);
+		publishCollectionChange({
+			slug,
+			op: "upsert"
+		});
+	});
+}
+/** Test-only: drive one storage-collection reconcile pass directly. */
+function _scheduleStorageReconcileForTesting(slug) {
+	return scheduleStorageReconcile(slug);
+}
+async function startWatcherFor(collection) {
+	const { slug, schema, dataDir } = collection;
 	try {
 		await mkdir(dataDir, { recursive: true });
-		await reconcileAllItems(slug, schema, dataDir, discoveryOpts);
+		await reconcileAllItems(collection, discoveryOpts);
 		const watcher = watch(dataDir, { persistent: false }, (_eventType, filename) => {
 			onEvent(slug, filename).catch((err) => {
 				log().warn("watcher event failed", {
@@ -565,7 +640,8 @@ async function startWatcherFor(slug, schema, dataDir) {
 			slug,
 			dataDir,
 			watcher,
-			schemaJson: JSON.stringify(schema)
+			schemaJson: JSON.stringify(schema),
+			collection
 		});
 		log().info("watcher started", {
 			slug,
@@ -587,12 +663,22 @@ async function startWatcherFor(slug, schema, dataDir) {
 *  and return — the running reconcile re-runs once after it completes.
 *  This collapses fs.watch's rapid-fire bursts (atomic rename surfaces as
 *  2-3 events) into a single reconcile + one trailing re-run. */
-function _scheduleItemReconcileForTesting(slug, schema, dataDir, itemId) {
-	return scheduleItemReconcile(slug, schema, dataDir, itemId);
-}
-function scheduleItemReconcile(slug, schema, dataDir, itemId) {
-	const key = `${slug}\x00${itemId}`;
-	const existing = itemSlots.get(key);
+function _scheduleItemReconcileForTesting(collection, itemId) {
+	return scheduleItemReconcile(collection, itemId);
+}
+function scheduleItemReconcile(collection, itemId) {
+	return runSingleFlight(itemSlots, `${collection.slug}\x00${itemId}`, () => reconcileItem(collection, itemId, discoveryOpts), () => publishItemChange(collection, itemId));
+}
+/** The shared single-flight loop behind both schedulers. Re-runs `pass`
+*  while events keep arriving — the trailing re-run captures any state
+*  change that landed during a prior pass. After each pass we read
+*  `pending` and zero it before the next iteration, so an event that
+*  fires *during* the last pass's await still triggers one more pass
+*  before the slot is freed. `onSettled`, if given, runs once in the
+*  `finally` after the slot is freed — the item scheduler uses it to
+*  publish exactly one live-refresh event per burst. */
+function runSingleFlight(slots, key, pass, onSettled) {
+	const existing = slots.get(key);
 	if (existing) {
 		existing.pending = true;
 		return existing.running;
@@ -606,16 +692,50 @@ function scheduleItemReconcile(slug, schema, dataDir, itemId) {
 			let keepGoing = true;
 			while (keepGoing) {
 				slot.pending = false;
-				await reconcileItem(slug, schema, dataDir, itemId, discoveryOpts);
+				await pass();
 				keepGoing = slot.pending;
 			}
 		} finally {
-			itemSlots.delete(key);
+			slots.delete(key);
+			if (onSettled) await onSettled();
 		}
 	})();
-	itemSlots.set(key, slot);
+	slots.set(key, slot);
 	return slot.running;
 }
+/** Emit the live-refresh event for one record. `op` is derived from
+*  whether the file is still there — `fs.watch` reports neither the kind
+*  of change nor, reliably, which of `rename`/`change` means what. Only
+*  file-backed collections reach here; a `storage` (db) collection has no
+*  per-record file and publishes wholesale in `scheduleStorageReconcile`. */
+async function publishItemChange(collection, itemId) {
+	const changeOp = await itemFileExists(collection.dataDir, itemId) ? "upsert" : "delete";
+	safePublish({
+		slug: collection.slug,
+		ids: [itemId],
+		op: changeOp
+	});
+}
+async function itemFileExists(dataDir, itemId) {
+	try {
+		await access(itemFilePath(dataDir, itemId));
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** The publisher is host-supplied, so treat it as untrusted: a throw here
+*  runs inside a `finally` and would mask the reconcile's own error. */
+function safePublish(payload) {
+	try {
+		publishCollectionChange(payload);
+	} catch (err) {
+		log().warn("collection change publish failed", {
+			slug: payload.slug,
+			error: errMsg(err)
+		});
+	}
+}
 /** Handle a single fs.watch event. Re-loads the collection (schema may
 *  have changed since startup), filters out non-record files, and
 *  forwards to the single-flighted reconciler. `filename === null` (rare,
@@ -624,16 +744,19 @@ async function onEvent(slug, filename) {
 	const collection = await loadCollection(slug, discoveryOpts);
 	if (!collection) return;
 	if (filename === null) {
-		await reconcileAllItems(slug, collection.schema, collection.dataDir, discoveryOpts);
-		await sweepStaleActiveEntries(discoveryOpts);
+		try {
+			await reconcileAllItems(collection, discoveryOpts);
+			await sweepStaleActiveEntries(discoveryOpts);
+		} finally {
+			safePublish({ slug });
+		}
 		return;
 	}
 	const name = typeof filename === "string" ? filename : filename.toString("utf-8");
 	if (!name.endsWith(".json") || name.startsWith(".")) return;
-	const itemId = name.slice(0, -5);
-	await scheduleItemReconcile(slug, collection.schema, collection.dataDir, itemId);
+	await scheduleItemReconcile(collection, name.slice(0, -5));
 }
 //#endregion
-export { _resetReconcilerLocksForTesting, _scheduleItemReconcileForTesting, _syncWatchersForTesting, _tickTimeTriggersForTesting, clearItemNotification, configureCollectionWatchers, evalNow, itemIsDone, reconcileAllItems, reconcileItem, resetCollectionWatchersConfig, resolveDisplayLabel, startCollectionWatchers, stopCollectionWatchers, sweepStaleActiveEntries };
+export { _resetReconcilerLocksForTesting, _scheduleItemReconcileForTesting, _scheduleStorageReconcileForTesting, _syncWatchersForTesting, _tickTimeTriggersForTesting, clearItemNotification, configureCollectionWatchers, evalNow, itemIsDone, reconcileAllItems, reconcileItem, resetCollectionWatchersConfig, resolveDisplayLabel, startCollectionWatchers, stopCollectionWatchers, sweepStaleActiveEntries };
 
 //# sourceMappingURL=index.js.map