@mulmoclaude/collection-plugin 0.5.2 → 0.5.6

package/dist/server.js

@@ -1,4 +1,4 @@
-import { n as INGEST_KINDS, t as FEED_SCHEDULES } from "./schema-DyfSfVzh.js";
+import { n as INGEST_KINDS, r as isFieldDrivenEvery, t as FEED_SCHEDULES } from "./schema-BcnitlL8.js";
 import { t as deriveAll } from "./deriveAll-BHcs1erT.js";
 import path from "node:path";
 import { promises, realpathSync } from "node:fs";
@@ -7,6 +7,7 @@ import { randomBytes, randomUUID } from "node:crypto";
 import { z } from "zod";
 //#region src/server/host.ts
 var current = null;
+var changePublisher = null;
 /** Wire the engine to a host. Call once at server startup, before any
 *  collection storage operation. Re-binding to a *different* host throws —
 *  silently redirecting later filesystem operations to another workspace
@@ -15,6 +16,22 @@ function configureCollectionHost(host) {
 	if (current !== null && current !== host) throw new Error("@mulmoclaude/collection-plugin/server: configureCollectionHost() was already called with a different host");
 	current = host;
 }
+/** Wire a publisher that broadcasts record-change events; the host bridges it
+*  to its pubsub. Kept SEPARATE from `configureCollectionHost` because the
+*  host's pubsub instance isn't ready at host-binding time (the binding is set
+*  at the top of server startup, the pubsub later). Optional: left unset, every
+*  write is silent — the default for tests and for a host that doesn't want
+*  live view updates. Pass `null` to detach (test teardown). */
+function setCollectionChangePublisher(publish) {
+	changePublisher = publish;
+}
+/** Broadcast a record-change event if a publisher is wired (no-op otherwise).
+*  Called from the write path (`writeItem`/`deleteItem`). The wired publisher is
+*  expected to be fire-and-forget (it wraps its own pubsub call in try/catch),
+*  so this stays a thin pass-through and never throws into the write. */
+function publishCollectionChange(payload) {
+	changePublisher?.(payload);
+}
 function requireHost() {
 	if (current === null) throw new Error("@mulmoclaude/collection-plugin/server: configureCollectionHost() was not called by the host");
 	return current;
@@ -391,13 +408,12 @@ async function writeItem(dataDir, itemId, item, opts = {}) {
 		} finally {
 			await handle.close();
 		}
-		return {
-			kind: "ok",
-			itemId: safeId,
-			item
-		};
-	}
-	await writeFileAtomic(filePath, payload);
+	} else await writeFileAtomic(filePath, payload);
+	if (opts.slug) publishCollectionChange({
+		slug: opts.slug,
+		ids: [safeId],
+		op: "upsert"
+	});
 	return {
 		kind: "ok",
 		itemId: safeId,
@@ -423,6 +439,11 @@ async function deleteItem(dataDir, itemId, opts = {}) {
 	const filePath = itemFilePath(dataDir, safeId);
 	try {
 		await unlink(filePath);
+		if (opts.slug) publishCollectionChange({
+			slug: opts.slug,
+			ids: [safeId],
+			op: "delete"
+		});
 		return {
 			kind: "ok",
 			itemId: safeId
@@ -777,7 +798,7 @@ var CustomViewSchema = z.object({
 	file: z.string().trim().min(1).refine(isSafeCustomViewPath, "must be a safe path under `views/` ending in `.html` (e.g. `views/year.html`; no `..`, no leading `/`, no backslash)"),
 	capabilities: z.array(z.enum(["read", "write"])).optional()
 });
-var EverySchema = z.object({
+var EveryLiteralSchema = z.object({
 	unit: z.enum([
 		"day",
 		"week",
@@ -786,7 +807,12 @@ var EverySchema = z.object({
 	]),
 	interval: z.number().int().min(1),
 	dayOfMonth: z.union([z.number().int().min(1).max(31), z.literal("last")]).optional()
-});
+}).strict();
+var EveryFieldDrivenSchema = z.object({
+	fromField: z.string().trim().min(1),
+	map: z.record(z.string(), EveryLiteralSchema)
+}).strict();
+var EverySchema = z.union([EveryLiteralSchema, EveryFieldDrivenSchema]);
 var SpawnSchema = z.object({
 	when: WhenSchema.optional(),
 	every: EverySchema,
@@ -828,6 +854,36 @@ function spawnSuccessorStartsInert(schema) {
 	if (spawn.set && Object.prototype.hasOwnProperty.call(spawn.set, field)) return !values.includes(String(spawn.set[field]));
 	return !(spawn.carry ?? []).includes(field);
 }
+function fieldDrivenSpawnEvery(schema) {
+	const every = schema.spawn?.every;
+	if (!every || !isFieldDrivenEvery(every)) return null;
+	return every;
+}
+function fieldDrivenFromFieldIsEnum(schema) {
+	const driven = fieldDrivenSpawnEvery(schema);
+	if (!driven) return true;
+	return schema.fields[driven.fromField]?.type === "enum";
+}
+function fieldDrivenMapCoversValues(schema) {
+	const driven = fieldDrivenSpawnEvery(schema);
+	if (!driven) return true;
+	const target = schema.fields[driven.fromField];
+	if (!target || target.type !== "enum" || target.values === void 0) return true;
+	const values = new Set(target.values);
+	const keys = Object.keys(driven.map);
+	return keys.length === values.size && keys.every((key) => values.has(key));
+}
+function fieldDrivenFromFieldCarried(schema) {
+	const driven = fieldDrivenSpawnEvery(schema);
+	if (!driven) return true;
+	const { carry, set } = schema.spawn ?? {};
+	if (set && Object.prototype.hasOwnProperty.call(set, driven.fromField)) {
+		const raw = set[driven.fromField];
+		if (raw === void 0 || raw === null || raw === "") return false;
+		return Object.prototype.hasOwnProperty.call(driven.map, String(raw));
+	}
+	return (carry ?? []).includes(driven.fromField);
+}
 var IngestSchemaZ = z.object({
 	kind: z.enum(INGEST_KINDS),
 	url: z.string().url(),
@@ -904,6 +960,15 @@ var CollectionSchemaZ = z.object({
 }).refine((schema) => spawnSuccessorStartsInert(schema), {
 	message: "`spawn` must leave the successor in a non-matching state (e.g. `set` the status to a pending value); seeding the predicate field to a matching value via `set`/`carry` would respawn forever",
 	path: ["spawn"]
+}).refine((schema) => fieldDrivenFromFieldIsEnum(schema), {
+	message: "`spawn.every.fromField` must name a top-level `enum` field declared in `fields`",
+	path: ["spawn"]
+}).refine((schema) => fieldDrivenMapCoversValues(schema), {
+	message: "`spawn.every.map` keys must exactly cover the `values` of the `enum` named by `fromField` (no missing or extra keys)",
+	path: ["spawn"]
+}).refine((schema) => fieldDrivenFromFieldCarried(schema), {
+	message: "`spawn.every.fromField` must appear in `spawn.carry`, or be written by `spawn.set` to a value present in `spawn.every.map`, so the successor keeps a resolvable recurrence interval",
+	path: ["spawn"]
 }).refine((schema) => schema.calendarField === void 0 || isDateLike(schema.fields[schema.calendarField]?.type), {
 	message: "schema `calendarField` must name a top-level `date` or `datetime` field declared in `fields`",
 	path: ["calendarField"]
@@ -1310,6 +1375,18 @@ function matchesWhen(when, schema, item) {
 	const raw = item[completionField];
 	return raw !== void 0 && raw !== null && completionDoneValues.includes(String(raw));
 }
+/** Resolve the literal `every` that applies to `sourceItem`. Literal-arm
+*  `spawn.every` passes through unchanged. Field-driven `spawn.every` reads
+*  `sourceItem[fromField]` and looks it up in `map`; an empty field or a
+*  value with no map entry yields null (caller skips + logs — see plan §5).
+*  Discovery rejects a map that doesn't cover the enum's values, so null
+*  here means a record that predates a map/enum edit. */
+function resolveEvery(every, sourceItem) {
+	if (!isFieldDrivenEvery(every)) return every;
+	const raw = sourceItem[every.fromField];
+	if (raw === void 0 || raw === null || raw === "") return null;
+	return every.map[String(raw)] ?? null;
+}
 /** Build the successor record purely from (schema, source record, source
 *  id). Returns null when the schema has no spawn/triggerField or the
 *  source's trigger date is unparseable. */
@@ -1318,7 +1395,9 @@ function computeSuccessor(schema, sourceItem, sourceId) {
 	if (!spawn || !triggerField) return null;
 	const srcDate = parseCivil(sourceItem[triggerField]);
 	if (srcDate === null) return null;
-	const next = advanceTriggerDate(srcDate, spawn.every);
+	const every = resolveEvery(spawn.every, sourceItem);
+	if (every === null) return null;
+	const next = advanceTriggerDate(srcDate, every);
 	const nextId = successorId(sourceId, next);
 	const record = {};
 	for (const field of spawn.carry ?? []) if (Object.prototype.hasOwnProperty.call(sourceItem, field)) record[field] = sourceItem[field];
@@ -1330,6 +1409,27 @@ function computeSuccessor(schema, sourceItem, sourceId) {
 		record
 	};
 }
+/** Warn precisely about which of `computeSuccessor`'s two null causes fired
+*  (plan §5): an unparseable source trigger date (the original cause), or a
+*  field-driven `every` whose record value has no `map` entry (a record that
+*  predates a map/enum edit — discovery rejects this statically otherwise). */
+function logSpawnSkip(slug, triggerField, every, sourceItem, sourceId) {
+	if (parseCivil(sourceItem[triggerField]) === null) {
+		log.warn("collections", "spawn skipped: source trigger date unparseable", {
+			slug,
+			sourceId,
+			triggerField
+		});
+		return;
+	}
+	const fromField = isFieldDrivenEvery(every) ? every.fromField : void 0;
+	log.warn("collections", "spawn skipped: no `every` mapping for frequency value", {
+		slug,
+		sourceId,
+		fromField,
+		value: fromField === void 0 ? void 0 : sourceItem[fromField]
+	});
+}
 /** Idempotently create the successor for `sourceItem` when it matches the
 *  spawn predicate. No-op when the schema declares no spawn, the
 *  predicate doesn't match, the trigger date is unparseable, or the
@@ -1341,11 +1441,7 @@ async function maybeSpawnSuccessor(slug, schema, dataDir, sourceItem, sourceId,
 	if (!matchesWhen(spawn.when, schema, sourceItem)) return;
 	const computed = computeSuccessor(schema, sourceItem, sourceId);
 	if (computed === null) {
-		log.warn("collections", "spawn skipped: source trigger date unparseable", {
-			slug,
-			sourceId,
-			triggerField: schema.triggerField
-		});
+		logSpawnSkip(slug, schema.triggerField, spawn.every, sourceItem, sourceId);
 		return;
 	}
 	if (matchesWhen(spawn.when, schema, computed.record)) {
@@ -1359,7 +1455,8 @@ async function maybeSpawnSuccessor(slug, schema, dataDir, sourceItem, sourceId,
 	try {
 		const result = await writeItem(dataDir, computed.id, computed.record, {
 			...ioOpts,
-			refuseOverwrite: true
+			refuseOverwrite: true,
+			slug
 		});
 		if (result.kind === "ok") log.info("collections", "spawned successor", {
 			slug,
@@ -1607,6 +1704,6 @@ async function deleteCustomView(collection, viewId, opts = {}) {
 	};
 }
 //#endregion
-export { COMPUTED_TYPES, CollectionSchemaZ, SCHEMA_FILE, acceptParsedSchema, advanceTriggerDate, buildActionSeedPrompt, buildCollectionActionSeedPrompt, computeSuccessor, configureCollectionHost, daysInMonth, deleteCollection, deleteCollectionRefusalMessage, deleteCustomView, deleteItem, discoverCollections, enrichItems, formatCivil, generateItemId, getWorkspaceRoot, isContainedInRoot, isContainedInWorkspace, isSafeActionTemplatePath, isSafeCustomViewPath, isSafeTemplatePath, isTriggerDue, itemFilePath, listItems, loadCollection, log, maybeSpawnSuccessor, parseCivil, readCustomViewHtml, readItem, readSkillTemplate, resolveCreateItemId, resolveDataDir, resolveTemplatePath, safeRecordId, safeSlugName, successorId, toDetail, toSummary, validateCollectionRecords, validateRecordObject, writeItem };
+export { COMPUTED_TYPES, CollectionSchemaZ, SCHEMA_FILE, acceptParsedSchema, advanceTriggerDate, buildActionSeedPrompt, buildCollectionActionSeedPrompt, computeSuccessor, configureCollectionHost, daysInMonth, deleteCollection, deleteCollectionRefusalMessage, deleteCustomView, deleteItem, discoverCollections, enrichItems, formatCivil, generateItemId, getWorkspaceRoot, isContainedInRoot, isContainedInWorkspace, isSafeActionTemplatePath, isSafeCustomViewPath, isSafeTemplatePath, isTriggerDue, itemFilePath, listItems, loadCollection, log, maybeSpawnSuccessor, parseCivil, publishCollectionChange, readCustomViewHtml, readItem, readSkillTemplate, resolveCreateItemId, resolveDataDir, resolveEvery, resolveTemplatePath, safeRecordId, safeSlugName, setCollectionChangePublisher, successorId, toDetail, toSummary, validateCollectionRecords, validateRecordObject, writeItem };
 
 //# sourceMappingURL=server.js.map