@trevonistrevon/pi-loop 0.5.4 → 0.5.5

package/dist/goal-store.js

@@ -1,136 +1,23 @@
-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 { reduceGoalState } from "./goal-reducer.js";
+import { ReducerBackedStore } from "./reducer-backed-store.js";
 const GOALS_DIR = join(homedir(), ".pi", "goals");
-const LOCK_RETRY_MS = 50;
-const LOCK_MAX_RETRIES = 100;
 const MAX_GOALS = 200;
-function acquireLock(lockPath) {
-    mkdirSync(dirname(lockPath), { recursive: true });
-    for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
-        try {
-            writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
-            return;
-        }
-        catch (e) {
-            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) {
-    try {
-        unlinkSync(lockPath);
-    }
-    catch { /* ignore */ }
-}
-function isProcessRunning(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export class GoalStore {
-    filePath;
-    lockPath;
-    lastLoadedSignature;
-    nextId = 1;
-    goals = new Map();
+export class GoalStore extends ReducerBackedStore {
     constructor(listIdOrPath) {
-        if (!listIdOrPath)
-            return;
-        const isAbsPath = isAbsolute(listIdOrPath);
-        const filePath = isAbsPath ? listIdOrPath : join(GOALS_DIR, `${listIdOrPath}.json`);
-        mkdirSync(dirname(filePath), { recursive: true });
-        this.filePath = filePath;
-        this.lockPath = filePath + ".lock";
-        this.load();
-    }
-    getFileSignature() {
-        if (!this.filePath || !existsSync(this.filePath))
-            return undefined;
-        const stat = statSync(this.filePath);
-        return `${stat.mtimeMs}:${stat.size}`;
-    }
-    load(force = false) {
-        if (!this.filePath)
-            return;
-        const signature = this.getFileSignature();
-        if (!signature)
-            return;
-        if (!force && signature === this.lastLoadedSignature)
-            return;
-        try {
-            const data = JSON.parse(readFileSync(this.filePath, "utf-8"));
-            this.nextId = data.nextId;
-            this.goals.clear();
-            for (const goal of data.goals) {
-                this.goals.set(goal.id, goal);
-            }
-            this.lastLoadedSignature = signature;
-        }
-        catch { /* corrupt file — start fresh */ }
-    }
-    save() {
-        if (!this.filePath)
-            return;
-        const data = {
-            nextId: this.nextId,
-            goals: Array.from(this.goals.values()),
-        };
-        const tmpPath = this.filePath + ".tmp";
-        writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-        renameSync(tmpPath, this.filePath);
-        this.lastLoadedSignature = this.getFileSignature();
-    }
-    withLock(fn) {
-        if (!this.lockPath)
-            return fn();
-        acquireLock(this.lockPath);
-        try {
-            this.load(true);
-            const result = fn();
-            this.save();
-            return result;
-        }
-        finally {
-            releaseLock(this.lockPath);
-        }
-    }
-    toReducerState() {
-        return {
-            nextId: this.nextId,
-            goalsById: Object.fromEntries(this.goals.entries()),
-        };
-    }
-    applyReducerEvent(event) {
-        const result = reduceGoalState(this.toReducerState(), event);
-        this.nextId = result.state.nextId;
-        this.goals = new Map(Object.entries(result.state.goalsById));
+        super({
+            baseDir: GOALS_DIR,
+            reduce: (state, event) => reduceGoalState(state, event),
+            toReducerState: (nextId, entries) => ({ nextId, goalsById: Object.fromEntries(entries.entries()) }),
+            fromReducerState: (state) => ({ nextId: state.nextId, entries: new Map(Object.entries(state.goalsById)) }),
+            serialize: (nextId, entries) => ({ nextId, goals: Array.from(entries.values()) }),
+            deserialize: (data) => ({ nextId: data.nextId, entries: new Map(data.goals.map((g) => [g.id, g])) }),
+        }, listIdOrPath);
     }
     create(title, description, scope, criteria, metadata) {
         return this.withLock(() => {
-            if (this.goals.size >= MAX_GOALS) {
+            if (this.entries.size >= MAX_GOALS) {
                 throw new Error(`Maximum of ${MAX_GOALS} goals reached. Archive some before creating new ones.`);
             }
             this.applyReducerEvent({
@@ -146,22 +33,12 @@ export class GoalStore {
                     metadata,
                 },
             });
-            return this.goals.get(String(this.nextId - 1));
+            return this.entries.get(String(this.nextId - 1));
         });
     }
-    get(id) {
-        if (this.filePath)
-            this.load();
-        return this.goals.get(id);
-    }
-    list() {
-        if (this.filePath)
-            this.load();
-        return Array.from(this.goals.values()).sort((a, b) => Number(a.id) - Number(b.id));
-    }
     activate(id) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_ACTIVATED",
@@ -171,12 +48,12 @@ export class GoalStore {
                 entityId: id,
                 payload: { id },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     recordProgress(id, progress) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_PROGRESS_RECORDED",
@@ -186,12 +63,12 @@ export class GoalStore {
                 entityId: id,
                 payload: { id, progress },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     markVerificationStarted(id) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_VERIFICATION_STARTED",
@@ -201,12 +78,12 @@ export class GoalStore {
                 entityId: id,
                 payload: { id },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     markVerified(id, reason, progress) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_VERIFICATION_PASSED",
@@ -216,12 +93,12 @@ export class GoalStore {
                 entityId: id,
                 payload: { id, reason, progress },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     markFailed(id, reason, progress) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_FAILED",
@@ -231,12 +108,12 @@ export class GoalStore {
                 entityId: id,
                 payload: { id, reason, progress },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     markBlocked(id, reason, progress) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_BLOCKED",
@@ -246,12 +123,12 @@ export class GoalStore {
                 entityId: id,
                 payload: { id, reason, progress },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     unblock(id) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_UNBLOCKED",
@@ -261,19 +138,19 @@ export class GoalStore {
                 entityId: id,
                 payload: { id },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     updateDetails(id, fields) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             if (fields.title === undefined
                 && fields.description === undefined
                 && fields.scope === undefined
                 && fields.criteria === undefined
                 && fields.metadata === undefined) {
-                return this.goals.get(id);
+                return this.entries.get(id);
             }
             this.applyReducerEvent({
                 type: "GOAL_UPDATED",
@@ -290,12 +167,12 @@ export class GoalStore {
                     metadata: fields.metadata,
                 },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     archive(id, reason) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_ARCHIVED",
@@ -305,7 +182,7 @@ export class GoalStore {
                 entityId: id,
                 payload: { id, reason },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
 }

package/dist/index.js

@@ -15,6 +15,7 @@
  */
 import { registerLoopCommand } from "./commands/loop-command.js";
 import { registerTasksCommand } from "./commands/tasks-command.js";
+import { atMaxFires } from "./loop-reducer.js";
 import { MonitorManager } from "./monitor-manager.js";
 import { createMonitorOnDoneRuntime } from "./runtime/monitor-ondone-runtime.js";
 import { createNotificationRuntime, } from "./runtime/notification-runtime.js";
@@ -158,7 +159,7 @@ export default function (pi) {
     // ── Loop fire handler ──
     function onLoopFire(entry) {
         debug(`loop:fire #${entry.id}`, { prompt: entry.prompt.slice(0, 50) });
-        if (entry.maxFires && (entry.fireCount ?? 0) >= entry.maxFires) {
+        if (atMaxFires(entry)) {
             debug(`loop #${entry.id} — reached maxFires ${entry.maxFires}, expiring`);
             store.delete(entry.id);
             return;

package/dist/loop-reducer.d.ts

@@ -1,5 +1,12 @@
 import type { LoopEntry, Trigger } from "./types.js";
 export declare const MAX_LOOP_EXPIRY_MS: number;
+/**
+ * Whether a loop has reached its fire cap. Single source of truth for the
+ * `maxFires` check shared by the fire callbacks (`onLoopFire` pre-fire guard and
+ * `TriggerSystem.fireLoop` post-fire cleanup). Each caller keeps its own timing;
+ * only the predicate is shared.
+ */
+export declare function atMaxFires(loop: Pick<LoopEntry, "maxFires" | "fireCount">): boolean;
 type ReducerSource = "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
 export interface LoopReducerState {
     nextId: number;

package/dist/loop-reducer.js

@@ -1,4 +1,13 @@
 export const MAX_LOOP_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Whether a loop has reached its fire cap. Single source of truth for the
+ * `maxFires` check shared by the fire callbacks (`onLoopFire` pre-fire guard and
+ * `TriggerSystem.fireLoop` post-fire cleanup). Each caller keeps its own timing;
+ * only the predicate is shared.
+ */
+export function atMaxFires(loop) {
+    return !!loop.maxFires && (loop.fireCount ?? 0) >= loop.maxFires;
+}
 function cloneState(state) {
     return {
         nextId: state.nextId,

package/dist/reducer-backed-store.d.ts

@@ -0,0 +1,65 @@
+import type { AnyReducerEffect } from "./coordinator.js";
+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 declare abstract class ReducerBackedStore<TEntry extends {
+    id: string;
+}, TState, TEvent, TData> {
+    protected filePath: string | undefined;
+    protected lockPath: string | undefined;
+    private lastLoadedSignature;
+    protected nextId: number;
+    protected entries: Map<string, TEntry>;
+    private readonly config;
+    constructor(config: ReducerBackedStoreConfig<TEntry, TState, TEvent, TData>, listIdOrPath?: string);
+    private getFileSignature;
+    private load;
+    private save;
+    protected withLock<T>(fn: () => T): T;
+    protected applyReducerEvent(event: TEvent): void;
+    /**
+     * Hook for reducer effects. Default no-op: durability is owned by
+     * {@link withLock}. Override to forward non-persistence effects.
+     */
+    protected onEffects(_effects: AnyReducerEffect[]): void;
+    /** Reload (signature-gated) and return the entry, or undefined. */
+    get(id: string): TEntry | undefined;
+    /** Reload (signature-gated) and return all entries sorted by numeric id. */
+    list(): TEntry[];
+    /** Remove the backing file when the store is empty. No-op for memory stores. */
+    deleteFileIfEmpty(): boolean;
+}

package/dist/reducer-backed-store.js

@@ -0,0 +1,160 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+const LOCK_RETRY_MS = 50;
+const LOCK_MAX_RETRIES = 100;
+function acquireLock(lockPath) {
+    mkdirSync(dirname(lockPath), { recursive: true });
+    for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
+        try {
+            writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
+            return;
+        }
+        catch (e) {
+            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) {
+    try {
+        unlinkSync(lockPath);
+    }
+    catch { /* ignore */ }
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 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 class ReducerBackedStore {
+    filePath;
+    lockPath;
+    lastLoadedSignature;
+    nextId = 1;
+    entries = new Map();
+    config;
+    constructor(config, listIdOrPath) {
+        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();
+    }
+    getFileSignature() {
+        if (!this.filePath || !existsSync(this.filePath))
+            return undefined;
+        const stat = statSync(this.filePath);
+        return `${stat.mtimeMs}:${stat.size}`;
+    }
+    load(force = false) {
+        if (!this.filePath)
+            return;
+        const signature = this.getFileSignature();
+        if (!signature)
+            return;
+        if (!force && signature === this.lastLoadedSignature)
+            return;
+        try {
+            const data = 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 */ }
+    }
+    save() {
+        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();
+    }
+    withLock(fn) {
+        if (!this.lockPath)
+            return fn();
+        acquireLock(this.lockPath);
+        try {
+            this.load(true);
+            const result = fn();
+            this.save();
+            return result;
+        }
+        finally {
+            releaseLock(this.lockPath);
+        }
+    }
+    applyReducerEvent(event) {
+        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.
+     */
+    onEffects(_effects) { }
+    /** Reload (signature-gated) and return the entry, or undefined. */
+    get(id) {
+        if (this.filePath)
+            this.load();
+        return this.entries.get(id);
+    }
+    /** Reload (signature-gated) and return all entries sorted by numeric id. */
+    list() {
+        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() {
+        if (!this.filePath || this.entries.size > 0)
+            return false;
+        try {
+            unlinkSync(this.filePath);
+        }
+        catch { /* ignore */ }
+        return true;
+    }
+}

package/dist/store.d.ts

@@ -1,17 +1,8 @@
-import type { LoopEntry, Trigger } from "./types.js";
-export declare class LoopStore {
-    private filePath;
-    private lockPath;
-    private lastLoadedSignature;
-    private nextId;
-    private loops;
+import { type LoopReducerEvent, type LoopReducerState } from "./loop-reducer.js";
+import { ReducerBackedStore } from "./reducer-backed-store.js";
+import type { LoopEntry, LoopStoreData, Trigger } from "./types.js";
+export declare class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducerState, LoopReducerEvent, LoopStoreData> {
     constructor(listIdOrPath?: string);
-    private getFileSignature;
-    private load;
-    private save;
-    private withLock;
-    private toReducerState;
-    private applyReducerEvent;
     create(trigger: Trigger, prompt: string, opts: {
         recurring: boolean;
         autoTask?: boolean;
@@ -19,8 +10,6 @@ export declare class LoopStore {
         readOnly?: boolean;
         maxFires?: number;
     }): LoopEntry;
-    get(id: string): LoopEntry | undefined;
-    list(): LoopEntry[];
     pause(id: string): LoopEntry | undefined;
     resume(id: string): LoopEntry | undefined;
     fire(id: string): LoopEntry | undefined;
@@ -35,5 +24,4 @@ export declare class LoopStore {
     clearExpired(): number;
     expireEventLoops(sessionStartedAt: number): number;
     clearAll(): number;
-    deleteFileIfEmpty(): boolean;
 }