@trevonistrevon/pi-loop 0.4.10 → 0.5.0

package/dist/store.js

@@ -1,11 +1,11 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
+import { reduceLoopState } from "./loop-reducer.js";
 const LOOPS_DIR = join(homedir(), ".pi", "loops");
 const LOCK_RETRY_MS = 50;
 const LOCK_MAX_RETRIES = 100;
 const MAX_LOOPS = 25;
-const MAX_EXPIRY_DAYS = 7;
 function acquireLock(lockPath) {
     for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
         try {
@@ -104,29 +104,39 @@ export class LoopStore {
             releaseLock(this.lockPath);
         }
     }
+    toReducerState() {
+        return {
+            nextId: this.nextId,
+            loopsById: Object.fromEntries(this.loops.entries()),
+        };
+    }
+    applyReducerEvent(event) {
+        const result = reduceLoopState(this.toReducerState(), event);
+        this.nextId = result.state.nextId;
+        this.loops = new Map(Object.entries(result.state.loopsById));
+    }
     create(trigger, prompt, opts) {
         return this.withLock(() => {
             if (this.loops.size >= MAX_LOOPS) {
                 throw new Error(`Maximum of ${MAX_LOOPS} loops reached. Delete some before creating new ones.`);
             }
             const now = Date.now();
-            const entry = {
-                id: String(this.nextId++),
-                prompt,
-                trigger,
-                status: "active",
-                recurring: opts.recurring,
-                autoTask: opts.autoTask,
-                taskBacklog: opts.taskBacklog,
-                readOnly: opts.readOnly,
-                maxFires: opts.maxFires,
-                fireCount: 0,
-                createdAt: now,
-                updatedAt: now,
-                expiresAt: now + MAX_EXPIRY_DAYS * 24 * 60 * 60 * 1000,
-            };
-            this.loops.set(entry.id, entry);
-            return entry;
+            this.applyReducerEvent({
+                type: "LOOP_CREATED",
+                at: now,
+                source: "tool",
+                entityType: "loop",
+                payload: {
+                    prompt,
+                    trigger,
+                    recurring: opts.recurring,
+                    autoTask: opts.autoTask,
+                    taskBacklog: opts.taskBacklog,
+                    readOnly: opts.readOnly,
+                    maxFires: opts.maxFires,
+                },
+            });
+            return this.loops.get(String(this.nextId - 1));
         });
     }
     get(id) {
@@ -145,31 +155,75 @@ export class LoopStore {
             if (!entry)
                 return { entry: undefined, changedFields: [] };
             const changedFields = [];
-            if (fields.status !== undefined) {
-                entry.status = fields.status;
+            const now = Date.now();
+            if (fields.status === "paused") {
+                this.applyReducerEvent({
+                    type: "LOOP_PAUSED",
+                    at: now,
+                    source: "tool",
+                    entityType: "loop",
+                    entityId: id,
+                    payload: { id },
+                });
                 changedFields.push("status");
             }
+            else if (fields.status === "active") {
+                this.applyReducerEvent({
+                    type: "LOOP_RESUMED",
+                    at: now,
+                    source: "tool",
+                    entityType: "loop",
+                    entityId: id,
+                    payload: { id },
+                });
+                changedFields.push("status");
+            }
+            const current = this.loops.get(id);
+            if (!current)
+                return { entry: undefined, changedFields };
             if (fields.trigger !== undefined) {
-                entry.trigger = fields.trigger;
+                current.trigger = fields.trigger;
                 changedFields.push("trigger");
             }
             if (fields.prompt !== undefined) {
-                entry.prompt = fields.prompt;
+                current.prompt = fields.prompt;
                 changedFields.push("prompt");
             }
             if (fields.fireCount !== undefined) {
-                entry.fireCount = fields.fireCount;
+                if (fields.fireCount === (current.fireCount ?? 0) + 1) {
+                    this.applyReducerEvent({
+                        type: "LOOP_FIRED",
+                        at: now,
+                        source: "system",
+                        entityType: "loop",
+                        entityId: id,
+                        payload: { id },
+                    });
+                }
+                else {
+                    current.fireCount = fields.fireCount;
+                    current.updatedAt = now;
+                }
                 changedFields.push("fireCount");
             }
-            entry.updatedAt = Date.now();
-            return { entry, changedFields };
+            if (fields.trigger !== undefined || fields.prompt !== undefined) {
+                current.updatedAt = now;
+            }
+            return { entry: this.loops.get(id), changedFields };
         });
     }
     delete(id) {
         return this.withLock(() => {
             if (!this.loops.has(id))
                 return false;
-            this.loops.delete(id);
+            this.applyReducerEvent({
+                type: "LOOP_DELETED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "loop",
+                entityId: id,
+                payload: { id },
+            });
             return true;
         });
     }
@@ -177,11 +231,18 @@ export class LoopStore {
         return this.withLock(() => {
             const now = Date.now();
             let count = 0;
-            for (const [id, entry] of this.loops) {
-                if (now >= entry.expiresAt) {
-                    this.loops.delete(id);
-                    count++;
-                }
+            for (const [id, entry] of [...this.loops.entries()]) {
+                if (now < entry.expiresAt)
+                    continue;
+                this.applyReducerEvent({
+                    type: "LOOP_EXPIRED",
+                    at: now,
+                    source: "system",
+                    entityType: "loop",
+                    entityId: id,
+                    payload: { id, reason: "expires_at" },
+                });
+                count++;
             }
             return count;
         });
@@ -189,27 +250,40 @@ export class LoopStore {
     expireEventLoops(sessionStartedAt) {
         return this.withLock(() => {
             let count = 0;
-            const toDelete = [];
-            for (const [id, entry] of this.loops) {
+            for (const [id, entry] of [...this.loops.entries()]) {
                 if (entry.status !== "active")
                     continue;
-                if (entry.trigger.type === "event" || entry.trigger.type === "hybrid") {
-                    if (entry.createdAt < sessionStartedAt) {
-                        toDelete.push(id);
-                        count++;
-                    }
-                }
+                if (entry.trigger.type !== "event" && entry.trigger.type !== "hybrid")
+                    continue;
+                if (entry.createdAt >= sessionStartedAt)
+                    continue;
+                this.applyReducerEvent({
+                    type: "LOOP_EXPIRED",
+                    at: sessionStartedAt,
+                    source: "session",
+                    entityType: "loop",
+                    entityId: id,
+                    payload: { id, reason: "resume_event_stale" },
+                });
+                count++;
             }
-            for (const id of toDelete)
-                this.loops.delete(id);
             return count;
         });
     }
     clearAll() {
         return this.withLock(() => {
-            const count = this.loops.size;
-            this.loops.clear();
-            return count;
+            const ids = [...this.loops.keys()];
+            for (const id of ids) {
+                this.applyReducerEvent({
+                    type: "LOOP_DELETED",
+                    at: Date.now(),
+                    source: "system",
+                    entityType: "loop",
+                    entityId: id,
+                    payload: { id },
+                });
+            }
+            return ids.length;
         });
     }
     deleteFileIfEmpty() {

package/dist/task-backlog-coordinator.d.ts

@@ -0,0 +1,12 @@
+import type { ReducerEffect, ReducerEvent } from "./coordinator.js";
+export type TaskBacklogEvent = ReducerEvent<"TASK_BACKLOG_EVALUATED", {
+    pendingCount: number;
+    threshold: number;
+}>;
+export type TaskBacklogEffect = ReducerEffect<"ENSURE_AUTO_TASK_WORKER", {
+    pendingCount: number;
+    threshold: number;
+}> | ReducerEffect<"CLEANUP_TASK_BACKLOG_LOOPS", {
+    pendingCount: number;
+}>;
+export declare function reduceTaskBacklogEvent(event: TaskBacklogEvent): TaskBacklogEffect[];

package/dist/task-backlog-coordinator.js

@@ -0,0 +1,22 @@
+export function reduceTaskBacklogEvent(event) {
+    if (event.type !== "TASK_BACKLOG_EVALUATED")
+        return [];
+    const { pendingCount, threshold } = event.payload;
+    if (pendingCount < 0)
+        return [];
+    if (pendingCount === 0) {
+        return [{
+                type: "CLEANUP_TASK_BACKLOG_LOOPS",
+                entityType: "task",
+                payload: { pendingCount },
+            }];
+    }
+    if (pendingCount >= threshold) {
+        return [{
+                type: "ENSURE_AUTO_TASK_WORKER",
+                entityType: "task",
+                payload: { pendingCount, threshold },
+            }];
+    }
+    return [];
+}

package/dist/task-reducer.d.ts

@@ -0,0 +1,66 @@
+import type { TaskEntry } from "./task-types.js";
+export interface TaskReducerState {
+    nextId: number;
+    tasksById: Record<string, TaskEntry>;
+}
+export type TaskReducerEvent = {
+    type: "TASK_CREATED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "task";
+    entityId?: string;
+    payload: {
+        subject: string;
+        description: string;
+        metadata?: Record<string, unknown>;
+    };
+} | {
+    type: "TASK_STARTED" | "TASK_COMPLETED" | "TASK_REOPENED" | "TASK_DELETED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "task";
+    entityId?: string;
+    payload: {
+        id: string;
+    };
+} | {
+    type: "TASK_UPDATED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "task";
+    entityId?: string;
+    payload: {
+        id: string;
+        subject?: string;
+        description?: string;
+    };
+} | {
+    type: "TASKS_PRUNED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "task";
+    entityId?: string;
+    payload: {
+        reason: "git_commit" | "zero_pending_cleanup" | "manual";
+    };
+};
+export type TaskReducerEffect = {
+    type: "PERSIST_TASK";
+    entityType: "task";
+    entityId: string;
+    payload: {
+        task: TaskEntry;
+    };
+} | {
+    type: "DELETE_TASK";
+    entityType: "task";
+    entityId: string;
+    payload: {
+        id: string;
+    };
+};
+export interface TaskReduceResult {
+    state: TaskReducerState;
+    effects: TaskReducerEffect[];
+}
+export declare function reduceTaskState(state: TaskReducerState, event: TaskReducerEvent): TaskReduceResult;

package/dist/task-reducer.js

@@ -0,0 +1,76 @@
+function cloneState(state) {
+    return {
+        nextId: state.nextId,
+        tasksById: { ...state.tasksById },
+    };
+}
+export function reduceTaskState(state, event) {
+    if (event.type === "TASK_CREATED") {
+        const next = cloneState(state);
+        const id = String(next.nextId++);
+        const task = {
+            id,
+            subject: event.payload.subject,
+            description: event.payload.description,
+            status: "pending",
+            createdAt: event.at,
+            updatedAt: event.at,
+            metadata: event.payload.metadata,
+        };
+        next.tasksById[id] = task;
+        return {
+            state: next,
+            effects: [{ type: "PERSIST_TASK", entityType: "task", entityId: id, payload: { task } }],
+        };
+    }
+    if (event.type === "TASKS_PRUNED") {
+        const next = cloneState(state);
+        const effects = [];
+        for (const [id, task] of Object.entries(next.tasksById)) {
+            if (task.status !== "completed")
+                continue;
+            delete next.tasksById[id];
+            effects.push({ type: "DELETE_TASK", entityType: "task", entityId: id, payload: { id } });
+        }
+        return { state: next, effects };
+    }
+    const id = event.payload.id;
+    const current = state.tasksById[id];
+    if (!current)
+        return { state, effects: [] };
+    if (event.type === "TASK_DELETED") {
+        const next = cloneState(state);
+        delete next.tasksById[id];
+        return {
+            state: next,
+            effects: [{ type: "DELETE_TASK", entityType: "task", entityId: id, payload: { id } }],
+        };
+    }
+    const next = cloneState(state);
+    const task = { ...current };
+    if (event.type === "TASK_STARTED") {
+        task.status = "in_progress";
+        task.updatedAt = event.at;
+    }
+    if (event.type === "TASK_COMPLETED") {
+        task.status = "completed";
+        task.updatedAt = event.at;
+        task.completedAt = event.at;
+    }
+    if (event.type === "TASK_REOPENED") {
+        task.status = "pending";
+        task.updatedAt = event.at;
+    }
+    if (event.type === "TASK_UPDATED") {
+        if (event.payload.subject !== undefined)
+            task.subject = event.payload.subject;
+        if (event.payload.description !== undefined)
+            task.description = event.payload.description;
+        task.updatedAt = event.at;
+    }
+    next.tasksById[id] = task;
+    return {
+        state: next,
+        effects: [{ type: "PERSIST_TASK", entityType: "task", entityId: id, payload: { task } }],
+    };
+}

package/dist/task-store.d.ts

@@ -8,6 +8,8 @@ export declare class TaskStore {
     private load;
     private save;
     private withLock;
+    private toReducerState;
+    private applyReducerEvent;
     create(subject: string, description: string, metadata?: Record<string, unknown>): TaskEntry;
     get(id: string): TaskEntry | undefined;
     list(): TaskEntry[];

package/dist/task-store.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
+import { reduceTaskState } from "./task-reducer.js";
 const TASKS_DIR = join(homedir(), ".pi", "tasks");
 const LOCK_RETRY_MS = 50;
 const LOCK_MAX_RETRIES = 100;
@@ -103,23 +104,31 @@ export class TaskStore {
             releaseLock(this.lockPath);
         }
     }
+    toReducerState() {
+        return {
+            nextId: this.nextId,
+            tasksById: Object.fromEntries(this.tasks.entries()),
+        };
+    }
+    applyReducerEvent(event) {
+        const result = reduceTaskState(this.toReducerState(), event);
+        this.nextId = result.state.nextId;
+        this.tasks = new Map(Object.entries(result.state.tasksById));
+    }
     create(subject, description, metadata) {
         return this.withLock(() => {
             if (this.tasks.size >= MAX_TASKS) {
                 throw new Error(`Maximum of ${MAX_TASKS} tasks reached. Delete some before creating new ones.`);
             }
             const now = Date.now();
-            const entry = {
-                id: String(this.nextId++),
-                subject,
-                description,
-                status: "pending",
-                createdAt: now,
-                updatedAt: now,
-                metadata,
-            };
-            this.tasks.set(entry.id, entry);
-            return entry;
+            this.applyReducerEvent({
+                type: "TASK_CREATED",
+                at: now,
+                source: "tool",
+                entityType: "task",
+                payload: { subject, description, metadata },
+            });
+            return this.tasks.get(String(this.nextId - 1));
         });
     }
     get(id) {
@@ -137,24 +146,66 @@ export class TaskStore {
             const entry = this.tasks.get(id);
             if (!entry)
                 return undefined;
-            if (fields.status !== undefined) {
-                entry.status = fields.status;
-                if (fields.status === "completed")
-                    entry.completedAt = Date.now();
+            const now = Date.now();
+            if (fields.status === "in_progress") {
+                this.applyReducerEvent({
+                    type: "TASK_STARTED",
+                    at: now,
+                    source: "tool",
+                    entityType: "task",
+                    entityId: id,
+                    payload: { id },
+                });
             }
-            if (fields.subject !== undefined)
-                entry.subject = fields.subject;
-            if (fields.description !== undefined)
-                entry.description = fields.description;
-            entry.updatedAt = Date.now();
-            return entry;
+            else if (fields.status === "completed") {
+                this.applyReducerEvent({
+                    type: "TASK_COMPLETED",
+                    at: now,
+                    source: "tool",
+                    entityType: "task",
+                    entityId: id,
+                    payload: { id },
+                });
+            }
+            else if (fields.status === "pending") {
+                this.applyReducerEvent({
+                    type: "TASK_REOPENED",
+                    at: now,
+                    source: "tool",
+                    entityType: "task",
+                    entityId: id,
+                    payload: { id },
+                });
+            }
+            if (fields.subject !== undefined || fields.description !== undefined) {
+                this.applyReducerEvent({
+                    type: "TASK_UPDATED",
+                    at: now,
+                    source: "tool",
+                    entityType: "task",
+                    entityId: id,
+                    payload: {
+                        id,
+                        subject: fields.subject,
+                        description: fields.description,
+                    },
+                });
+            }
+            return this.tasks.get(id);
         });
     }
     delete(id) {
         return this.withLock(() => {
             if (!this.tasks.has(id))
                 return false;
-            this.tasks.delete(id);
+            this.applyReducerEvent({
+                type: "TASK_DELETED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "task",
+                entityId: id,
+                payload: { id },
+            });
             return true;
         });
     }
@@ -168,14 +219,15 @@ export class TaskStore {
     }
     sweepCompleted() {
         return this.withLock(() => {
-            let count = 0;
-            for (const [id, entry] of this.tasks) {
-                if (entry.status === "completed") {
-                    this.tasks.delete(id);
-                    count++;
-                }
-            }
-            return count;
+            const before = this.tasks.size;
+            this.applyReducerEvent({
+                type: "TASKS_PRUNED",
+                at: Date.now(),
+                source: "system",
+                entityType: "task",
+                payload: { reason: "manual" },
+            });
+            return before - this.tasks.size;
         });
     }
 }