@trevonistrevon/pi-loop 0.5.3 → 0.5.5

package/src/reducer-backed-store.ts

@@ -0,0 +1,168 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+import type { AnyReducerEffect } from "./coordinator.js";
+
+const LOCK_RETRY_MS = 50;
+const LOCK_MAX_RETRIES = 100;
+
+function acquireLock(lockPath: string): void {
+  mkdirSync(dirname(lockPath), { recursive: true });
+  for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
+    try {
+      writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
+      return;
+    } catch (e: any) {
+      if (e.code === "EEXIST") {
+        try {
+          const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
+          if (!pid || !isProcessRunning(pid)) {
+            try { unlinkSync(lockPath); } catch { /* ignore */ }
+            continue;
+          }
+        } catch { /* ignore read errors */ }
+        const start = Date.now();
+        while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
+        continue;
+      }
+      throw e;
+    }
+  }
+  throw new Error(`Failed to acquire lock: ${lockPath}`);
+}
+
+function releaseLock(lockPath: string): void {
+  try { unlinkSync(lockPath); } catch { /* ignore */ }
+}
+
+function isProcessRunning(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+export interface ReducerResult<TState> {
+  state: TState;
+  effects: AnyReducerEffect[];
+}
+
+/**
+ * Per-store glue the base needs to translate between its internal
+ * `{ nextId, entries }` representation, the pure reducer's state shape, and the
+ * on-disk JSON shape. Each is a small, allocation-only function.
+ */
+export interface ReducerBackedStoreConfig<TEntry, TState, TEvent, TData> {
+  /** Directory for `<listId>.json` when constructed with a bare list id. */
+  baseDir: string;
+  reduce: (state: TState, event: TEvent) => ReducerResult<TState>;
+  toReducerState: (nextId: number, entries: Map<string, TEntry>) => TState;
+  fromReducerState: (state: TState) => { nextId: number; entries: Map<string, TEntry> };
+  serialize: (nextId: number, entries: Map<string, TEntry>) => TData;
+  deserialize: (data: TData) => { nextId: number; entries: Map<string, TEntry> };
+}
+
+/**
+ * Shared persistence + reducer-dispatch machinery for the file-backed entity
+ * stores (loops, tasks, goals). Owns file locking, signature-gated load, atomic
+ * save, and reducer application; subclasses add only their entity-specific
+ * command methods.
+ *
+ * Durability boundary: every mutation runs inside {@link withLock}, which saves
+ * the whole file unconditionally after the callback. Reducer effects are
+ * therefore *not* the persistence mechanism — they are surfaced to
+ * {@link onEffects} (default: no-op) so cross-entity effects (e.g.
+ * `DISPATCH_EVENT`, `REQUEST_GOAL_VERIFICATION`) can be forwarded by the runtime
+ * without being silently dropped at the reducer call site.
+ */
+export abstract class ReducerBackedStore<TEntry extends { id: string }, TState, TEvent, TData> {
+  protected filePath: string | undefined;
+  protected lockPath: string | undefined;
+  private lastLoadedSignature: string | undefined;
+
+  protected nextId = 1;
+  protected entries = new Map<string, TEntry>();
+
+  private readonly config: ReducerBackedStoreConfig<TEntry, TState, TEvent, TData>;
+
+  constructor(config: ReducerBackedStoreConfig<TEntry, TState, TEvent, TData>, listIdOrPath?: string) {
+    this.config = config;
+    if (!listIdOrPath) return;
+    const filePath = isAbsolute(listIdOrPath) ? listIdOrPath : join(config.baseDir, `${listIdOrPath}.json`);
+    mkdirSync(dirname(filePath), { recursive: true });
+    this.filePath = filePath;
+    this.lockPath = `${filePath}.lock`;
+    this.load();
+  }
+
+  private getFileSignature(): string | undefined {
+    if (!this.filePath || !existsSync(this.filePath)) return undefined;
+    const stat = statSync(this.filePath);
+    return `${stat.mtimeMs}:${stat.size}`;
+  }
+
+  private load(force = false): void {
+    if (!this.filePath) return;
+    const signature = this.getFileSignature();
+    if (!signature) return;
+    if (!force && signature === this.lastLoadedSignature) return;
+    try {
+      const data: TData = JSON.parse(readFileSync(this.filePath, "utf-8"));
+      const { nextId, entries } = this.config.deserialize(data);
+      this.nextId = nextId;
+      this.entries = entries;
+      this.lastLoadedSignature = signature;
+    } catch { /* corrupt file — start fresh */ }
+  }
+
+  private save(): void {
+    if (!this.filePath) return;
+    const data = this.config.serialize(this.nextId, this.entries);
+    const tmpPath = `${this.filePath}.tmp`;
+    writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+    renameSync(tmpPath, this.filePath);
+    this.lastLoadedSignature = this.getFileSignature();
+  }
+
+  protected withLock<T>(fn: () => T): T {
+    if (!this.lockPath) return fn();
+    acquireLock(this.lockPath);
+    try {
+      this.load(true);
+      const result = fn();
+      this.save();
+      return result;
+    } finally {
+      releaseLock(this.lockPath);
+    }
+  }
+
+  protected applyReducerEvent(event: TEvent): void {
+    const result = this.config.reduce(this.config.toReducerState(this.nextId, this.entries), event);
+    const { nextId, entries } = this.config.fromReducerState(result.state);
+    this.nextId = nextId;
+    this.entries = entries;
+    if (result.effects.length > 0) this.onEffects(result.effects);
+  }
+
+  /**
+   * Hook for reducer effects. Default no-op: durability is owned by
+   * {@link withLock}. Override to forward non-persistence effects.
+   */
+  protected onEffects(_effects: AnyReducerEffect[]): void { /* no-op by default */ }
+
+  /** Reload (signature-gated) and return the entry, or undefined. */
+  get(id: string): TEntry | undefined {
+    if (this.filePath) this.load();
+    return this.entries.get(id);
+  }
+
+  /** Reload (signature-gated) and return all entries sorted by numeric id. */
+  list(): TEntry[] {
+    if (this.filePath) this.load();
+    return Array.from(this.entries.values()).sort((a, b) => Number(a.id) - Number(b.id));
+  }
+
+  /** Remove the backing file when the store is empty. No-op for memory stores. */
+  deleteFileIfEmpty(): boolean {
+    if (!this.filePath || this.entries.size > 0) return false;
+    try { unlinkSync(this.filePath); } catch { /* ignore */ }
+    return true;
+  }
+}

package/src/store.ts

@@ -1,127 +1,30 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
+import { join } from "node:path";
 import { type LoopReducerEvent, type LoopReducerState, reduceLoopState } from "./loop-reducer.js";
+import { ReducerBackedStore } from "./reducer-backed-store.js";
 import type { LoopEntry, LoopStoreData, Trigger } from "./types.js";
 
 const LOOPS_DIR = join(homedir(), ".pi", "loops");
-const LOCK_RETRY_MS = 50;
-const LOCK_MAX_RETRIES = 100;
 const MAX_LOOPS = 25;
 
-function acquireLock(lockPath: string): void {
-  for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
-    try {
-      writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
-      return;
-    } catch (e: any) {
-      if (e.code === "EEXIST") {
-        try {
-          const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
-          if (!pid || !isProcessRunning(pid)) {
-            try { unlinkSync(lockPath); } catch { /* ignore */ }
-            continue;
-          }
-        } catch { /* ignore read errors */ }
-        const start = Date.now();
-        while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
-        continue;
-      }
-      throw e;
-    }
-  }
-  throw new Error(`Failed to acquire lock: ${lockPath}`);
-}
-
-function releaseLock(lockPath: string): void {
-  try { unlinkSync(lockPath); } catch { /* ignore */ }
-}
-
-function isProcessRunning(pid: number): boolean {
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
-
-export class LoopStore {
-  private filePath: string | undefined;
-  private lockPath: string | undefined;
-  private lastLoadedSignature: string | undefined;
-
-  private nextId = 1;
-  private loops = new Map<string, LoopEntry>();
-
+export class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducerState, LoopReducerEvent, LoopStoreData> {
   constructor(listIdOrPath?: string) {
-    if (!listIdOrPath) return;
-    const isAbsPath = isAbsolute(listIdOrPath);
-    const filePath = isAbsPath ? listIdOrPath : join(LOOPS_DIR, `${listIdOrPath}.json`);
-    mkdirSync(dirname(filePath), { recursive: true });
-    this.filePath = filePath;
-    this.lockPath = filePath + ".lock";
-    this.load();
-  }
-
-  private getFileSignature(): string | undefined {
-    if (!this.filePath || !existsSync(this.filePath)) return undefined;
-    const stat = statSync(this.filePath);
-    return `${stat.mtimeMs}:${stat.size}`;
-  }
-
-  private load(force = false): void {
-    if (!this.filePath) return;
-    const signature = this.getFileSignature();
-    if (!signature) return;
-    if (!force && signature === this.lastLoadedSignature) return;
-    try {
-      const data: LoopStoreData = JSON.parse(readFileSync(this.filePath, "utf-8"));
-      this.nextId = data.nextId;
-      this.loops.clear();
-      for (const loop of data.loops) {
-        this.loops.set(loop.id, loop);
-      }
-      this.lastLoadedSignature = signature;
-    } catch { /* corrupt file — start fresh */ }
-  }
-
-  private save(): void {
-    if (!this.filePath) return;
-    const data: LoopStoreData = {
-      nextId: this.nextId,
-      loops: Array.from(this.loops.values()),
-    };
-    const tmpPath = this.filePath + ".tmp";
-    writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-    renameSync(tmpPath, this.filePath);
-    this.lastLoadedSignature = this.getFileSignature();
-  }
-
-  private withLock<T>(fn: () => T): T {
-    if (!this.lockPath) return fn();
-    acquireLock(this.lockPath);
-    try {
-      this.load(true);
-      const result = fn();
-      this.save();
-      return result;
-    } finally {
-      releaseLock(this.lockPath);
-    }
-  }
-
-  private toReducerState(): LoopReducerState {
-    return {
-      nextId: this.nextId,
-      loopsById: Object.fromEntries(this.loops.entries()),
-    };
-  }
-
-  private applyReducerEvent(event: LoopReducerEvent): void {
-    const result = reduceLoopState(this.toReducerState(), event);
-    this.nextId = result.state.nextId;
-    this.loops = new Map(Object.entries(result.state.loopsById));
+    super(
+      {
+        baseDir: LOOPS_DIR,
+        reduce: (state, event) => reduceLoopState(state, event),
+        toReducerState: (nextId, entries) => ({ nextId, loopsById: Object.fromEntries(entries.entries()) }),
+        fromReducerState: (state) => ({ nextId: state.nextId, entries: new Map(Object.entries(state.loopsById)) }),
+        serialize: (nextId, entries) => ({ nextId, loops: Array.from(entries.values()) }),
+        deserialize: (data) => ({ nextId: data.nextId, entries: new Map(data.loops.map((l) => [l.id, l])) }),
+      },
+      listIdOrPath,
+    );
   }
 
   create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: boolean; taskBacklog?: boolean; readOnly?: boolean; maxFires?: number }): LoopEntry {
     return this.withLock(() => {
-      if (this.loops.size >= MAX_LOOPS) {
+      if (this.entries.size >= MAX_LOOPS) {
         throw new Error(`Maximum of ${MAX_LOOPS} loops reached. Delete some before creating new ones.`);
       }
       const now = Date.now();
@@ -140,23 +43,13 @@ export class LoopStore {
           maxFires: opts.maxFires,
         },
       });
-      return this.loops.get(String(this.nextId - 1))!;
+      return this.entries.get(String(this.nextId - 1))!;
     });
   }
 
-  get(id: string): LoopEntry | undefined {
-    if (this.filePath) this.load();
-    return this.loops.get(id);
-  }
-
-  list(): LoopEntry[] {
-    if (this.filePath) this.load();
-    return Array.from(this.loops.values()).sort((a, b) => Number(a.id) - Number(b.id));
-  }
-
   pause(id: string): LoopEntry | undefined {
     return this.withLock(() => {
-      const entry = this.loops.get(id);
+      const entry = this.entries.get(id);
       if (!entry) return undefined;
       this.applyReducerEvent({
         type: "LOOP_PAUSED",
@@ -166,13 +59,13 @@ export class LoopStore {
         entityId: id,
         payload: { id },
       });
-      return this.loops.get(id);
+      return this.entries.get(id);
     });
   }
 
   resume(id: string): LoopEntry | undefined {
     return this.withLock(() => {
-      const entry = this.loops.get(id);
+      const entry = this.entries.get(id);
       if (!entry) return undefined;
       this.applyReducerEvent({
         type: "LOOP_RESUMED",
@@ -182,13 +75,13 @@ export class LoopStore {
         entityId: id,
         payload: { id },
       });
-      return this.loops.get(id);
+      return this.entries.get(id);
     });
   }
 
   fire(id: string): LoopEntry | undefined {
     return this.withLock(() => {
-      const entry = this.loops.get(id);
+      const entry = this.entries.get(id);
       if (!entry) return undefined;
       this.applyReducerEvent({
         type: "LOOP_FIRED",
@@ -198,13 +91,13 @@ export class LoopStore {
         entityId: id,
         payload: { id },
       });
-      return this.loops.get(id);
+      return this.entries.get(id);
     });
   }
 
   updateMetadata(id: string, fields: { trigger?: Trigger; prompt?: string }): { entry: LoopEntry | undefined; changedFields: string[] } {
     return this.withLock(() => {
-      const current = this.loops.get(id);
+      const current = this.entries.get(id);
       if (!current) return { entry: undefined, changedFields: [] };
 
       const changedFields: string[] = [];
@@ -222,13 +115,13 @@ export class LoopStore {
         current.updatedAt = now;
       }
 
-      return { entry: this.loops.get(id), changedFields };
+      return { entry: this.entries.get(id), changedFields };
     });
   }
 
   delete(id: string): boolean {
     return this.withLock(() => {
-      if (!this.loops.has(id)) return false;
+      if (!this.entries.has(id)) return false;
       this.applyReducerEvent({
         type: "LOOP_DELETED",
         at: Date.now(),
@@ -245,7 +138,7 @@ export class LoopStore {
     return this.withLock(() => {
       const now = Date.now();
       let count = 0;
-      for (const [id, entry] of [...this.loops.entries()]) {
+      for (const [id, entry] of [...this.entries.entries()]) {
         if (now < entry.expiresAt) continue;
         this.applyReducerEvent({
           type: "LOOP_EXPIRED",
@@ -264,7 +157,7 @@ export class LoopStore {
   expireEventLoops(sessionStartedAt: number): number {
     return this.withLock(() => {
       let count = 0;
-      for (const [id, entry] of [...this.loops.entries()]) {
+      for (const [id, entry] of [...this.entries.entries()]) {
         if (entry.status !== "active") continue;
         if (entry.trigger.type !== "event" && entry.trigger.type !== "hybrid") continue;
         if (entry.createdAt >= sessionStartedAt) continue;
@@ -284,7 +177,7 @@ export class LoopStore {
 
   clearAll(): number {
     return this.withLock(() => {
-      const ids = [...this.loops.keys()];
+      const ids = [...this.entries.keys()];
       for (const id of ids) {
         this.applyReducerEvent({
           type: "LOOP_DELETED",
@@ -298,10 +191,4 @@ export class LoopStore {
       return ids.length;
     });
   }
-
-  deleteFileIfEmpty(): boolean {
-    if (!this.filePath || this.loops.size > 0) return false;
-    try { unlinkSync(this.filePath); } catch { /* ignore */ }
-    return true;
-  }
 }

package/src/task-reducer.ts

@@ -136,6 +136,9 @@ export function reduceTaskState(state: TaskReducerState, event: TaskReducerEvent
   if (event.type === "TASK_REOPENED") {
     task.status = "pending";
     task.updatedAt = event.at;
+    // `completedAt` is intentionally retained: it records the most recent
+    // completion, not "is currently complete" (use `status` for that). A
+    // reopened task keeps the timestamp of when it was last completed.
   }
 
   if (event.type === "TASK_UPDATED") {