@lmzhen/dsh-evolution-feedback 0.1.0-rc.70 → 0.1.0-rc.71

package/lib/index.js

@@ -1,5 +1,5 @@
 import z from "@deepseek-ai/schemastery";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 //#region ../evolution-core/src/io.ts
@@ -41,6 +41,14 @@ function evolutionIoAdapter(provider) {
 		}
 	};
 }
+/** Active-log split point (rc.71): when the active log reaches this many events
+* the older half is rotated into an archive; the active stays bounded so a
+* single append stays O(active) instead of O(total-history). Tunable default —
+* callers may override per append (the tests use small values). */
+const EVENT_LOG_ROTATE_AT = 4e3;
+/** Archive file prefix: `events-<lastArchivedSeq>.json`. The active file is
+* `events.json` and never matches this glob. */
+const EVENT_ARCHIVE_PREFIX = "events-";
 function eventsFile(home) {
 	return join(home, "evolution", "events.json");
 }
@@ -72,31 +80,74 @@ function parseEvolutionEvents(raw) {
 * computed inside the transact, so two processes appending concurrently never
 * collide. A malformed log is refused (bytes preserved) and the append fails.
 * Returns the assigned seq.
+*
+* Rotation (rc.71, 007 design): when the active log reaches `rotateAt`, the
+* older half is copied into an archive inside the SAME transact (the archive
+* path has its own lock, so no recursion) and the active is replaced with the
+* newer half + the new event. seqs stay globally monotonic; a crash between
+* archive write and active write leaves both copies, which the timeline merge
+* dedupes by seq. An archive-write failure aborts the append (active keeps the
+* full old content — no loss) and the caller's best-effort handling applies.
 */
-async function appendEvolutionEvent(io, path, event) {
+async function appendEvolutionEvent(io, path, event, rotateAt = EVENT_LOG_ROTATE_AT) {
 	let assigned = 0;
-	await transactIo(io, path, (current) => {
+	await transactIo(io, path, async (current) => {
 		if (current !== null && current.trim() !== "") try {
 			JSON.parse(current);
 		} catch {
-			return Promise.resolve(current);
+			return current;
 		}
-		const events = parseEvolutionEvents(current);
-		const maxSeq = events.reduce((max, entry) => Math.max(max, entry.seq), 0);
+		const nextEvents = await rotateIfDue(io, path, parseEvolutionEvents(current), rotateAt);
+		const maxSeq = nextEvents.reduce((max, entry) => Math.max(max, entry.seq), 0);
 		const record = {
 			...event,
 			seq: maxSeq + 1,
 			at: (/* @__PURE__ */ new Date()).toISOString()
 		};
 		assigned = record.seq;
-		return Promise.resolve(JSON.stringify({
+		return JSON.stringify({
 			version: 1,
-			events: [...events, record]
-		}, null, 2));
+			events: [...nextEvents, record]
+		}, null, 2);
 	});
 	if (assigned === 0) throw new Error(`evolution event log is malformed and was not touched: ${path}`);
 	return assigned;
 }
+/**
+* Split the active log at its midpoint when due: the older half is written to
+* `events-<lastArchivedSeq>.json` (await — a failed archive write aborts the
+* append so the active is never truncated without its copy), old archives are
+* pruned, and the newer half is returned as the next active body. No-op when
+* under the threshold.
+*/
+async function rotateIfDue(io, path, events, rotateAt) {
+	if (events.length < rotateAt) return events;
+	const mid = Math.ceil(events.length / 2);
+	const head = events.slice(0, mid);
+	const tail = events.slice(mid);
+	const anchor = tail[0]?.seq ?? events[events.length - 1]?.seq ?? 0;
+	const archivePath = join(dirname(path), `${EVENT_ARCHIVE_PREFIX}${anchor - 1}.json`);
+	await io.writeText(archivePath, JSON.stringify({
+		version: 1,
+		events: head
+	}, null, 2));
+	await retainEventArchives(io, path);
+	return tail;
+}
+/**
+* Prune old event archives (rc.71): keep the newest `EVENT_LOG_RETAIN_ARCHIVES`.
+* The name's numeric part is the last archived seq, so ordering is NUMERIC —
+* lexicographic would rank `events-10` before `events-2`. Best-effort per
+* removal; exported for the retention test.
+*/
+async function retainEventArchives(io, path) {
+	const dir = dirname(path);
+	const names = (await io.list(dir)).filter((name) => name.startsWith("events-") && name.endsWith(".json"));
+	const archiveSeq = (name) => Number.parseInt(name.slice(7, name.length - 5), 10) || 0;
+	names.sort((a, b) => archiveSeq(a) - archiveSeq(b));
+	const excess = names.slice(0, Math.max(0, names.length - 10));
+	for (const name of excess) await io.remove(join(dir, name)).catch(() => {});
+}
 /** Read the event log; a missing/whitespace-only file reads as empty,
 * corrupt content is flagged (and refused on append). */
 async function readEvolutionEvents(io, path) {
@@ -122,6 +173,30 @@ async function readEvolutionEvents(io, path) {
 		};
 	}
 }
+/**
+* Read the full timeline (rc.71): active log + all archives, merged by seq
+* (active copy wins, duplicates only arise from the rotation crash window),
+* sorted ascending. Per-file malformed flag as in `readEvolutionEvents`; a
+* malformed ARCHIVE is skipped (never bricks the boot) and still flagged.
+*/
+async function readEvolutionTimeline(io, path) {
+	const dir = dirname(path);
+	const names = (await io.list(dir)).filter((name) => name.startsWith("events-") && name.endsWith(".json")).sort();
+	let malformed = false;
+	const bySeq = /* @__PURE__ */ new Map();
+	for (const name of names) {
+		const read = await readEvolutionEvents(io, join(dir, name));
+		if (read.malformed) malformed = true;
+		for (const event of read.events) bySeq.set(event.seq, event);
+	}
+	const active = await readEvolutionEvents(io, path);
+	if (active.malformed) malformed = true;
+	for (const event of active.events) bySeq.set(event.seq, event);
+	return {
+		events: [...bySeq.values()].sort((a, b) => a.seq - b.seq),
+		malformed
+	};
+}
 //#endregion
 //#region ../evolution-core/src/prompts.ts
 /**
@@ -393,13 +468,14 @@ var EvolutionFeedback = class {
 		if (!path || !eventsPath) return;
 		await this.mutate(async () => {
 			const rawEvents = await io.readText(eventsPath);
-			if (rawEvents === null || rawEvents.trim() === "") {
+			const archiveNames = (await io.list(dirname(eventsPath))).filter((name) => name.startsWith("events-") && name.endsWith(".json"));
+			if ((rawEvents === null || rawEvents.trim() === "") && archiveNames.length === 0) {
 				const aggregate = parseAggregate(await io.readText(path));
 				if (aggregate) try {
 					await migrateFeedbackEvents(io, eventsPath, aggregate);
 				} catch {}
 			}
-			const { events } = await readEvolutionEvents(io, eventsPath);
+			const { events } = await readEvolutionTimeline(io, eventsPath);
 			const cache = parseCache(await io.readText(path));
 			const maxSeq = events.reduce((max, event) => Math.max(max, event.seq), 0);
 			const truth = cache ? foldWithDelta(cache, events) : foldFeedbackState(events);
@@ -472,7 +548,7 @@ var EvolutionFeedback = class {
 		if (!path || !eventsPath || !recordIo) return Promise.resolve();
 		return this.mutate(async () => {
 			try {
-				const { events } = await readEvolutionEvents(recordIo, eventsPath);
+				const { events } = await readEvolutionTimeline(recordIo, eventsPath);
 				const maxSeq = events.reduce((max, event) => Math.max(max, event.seq), 0);
 				if (maxSeq === 0) return;
 				await recordIo.writeText(path, JSON.stringify({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-feedback",
   "description": "Feedback-to-quality scoring for self-evolution (community build)",
-  "version": "0.1.0-rc.70",
+  "version": "0.1.0-rc.71",
   "publishConfig": {
     "access": "public"
   },
@@ -37,13 +37,13 @@
   "peerDependencies": {
     "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
     "@deepseek-ai/cordis": "^4.0.1",
-    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.70",
-    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.70"
+    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.71",
+    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.71"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
-    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.70",
-    "@lmzhen/dsh-evolution-io-node": "^0.1.0-rc.70",
-    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.70"
+    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.71",
+    "@lmzhen/dsh-evolution-io-node": "^0.1.0-rc.71",
+    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.71"
   }
 }