@trevonistrevon/pi-loop 0.4.10 → 0.5.0

package/src/store.ts

@@ -1,13 +1,13 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
+import { type LoopReducerEvent, type LoopReducerState, reduceLoopState } from "./loop-reducer.js";
 import type { LoopEntry, LoopStatus, 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;
-const MAX_EXPIRY_DAYS = 7;
 
 function acquireLock(lockPath: string): void {
   for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
@@ -95,29 +95,41 @@ export class LoopStore {
     }
   }
 
+  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));
+  }
+
   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) {
         throw new Error(`Maximum of ${MAX_LOOPS} loops reached. Delete some before creating new ones.`);
       }
       const now = Date.now();
-      const entry: LoopEntry = {
-        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))!;
     });
   }
 
@@ -137,31 +149,77 @@ export class LoopStore {
       if (!entry) return { entry: undefined, changedFields: [] };
 
       const changedFields: string[] = [];
-      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: string): boolean {
     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;
     });
   }
@@ -170,11 +228,17 @@ 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;
     });
@@ -183,26 +247,38 @@ export class LoopStore {
   expireEventLoops(sessionStartedAt: number): number {
     return this.withLock(() => {
       let count = 0;
-      const toDelete: string[] = [];
-      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(): number {
     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;
     });
   }
 

package/src/task-backlog-coordinator.ts

@@ -0,0 +1,32 @@
+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 function reduceTaskBacklogEvent(event: TaskBacklogEvent): TaskBacklogEffect[] {
+  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/src/task-reducer.ts

@@ -0,0 +1,152 @@
+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[];
+}
+
+function cloneState(state: TaskReducerState): TaskReducerState {
+  return {
+    nextId: state.nextId,
+    tasksById: { ...state.tasksById },
+  };
+}
+
+export function reduceTaskState(state: TaskReducerState, event: TaskReducerEvent): TaskReduceResult {
+  if (event.type === "TASK_CREATED") {
+    const next = cloneState(state);
+    const id = String(next.nextId++);
+    const task: TaskEntry = {
+      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: TaskReducerEffect[] = [];
+    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: TaskEntry = { ...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/src/task-store.ts

@@ -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, type TaskReducerEvent, type TaskReducerState } from "./task-reducer.js";
 import type { TaskEntry, TaskStatus, TaskStoreData } from "./task-types.js";
 
 const TASKS_DIR = join(homedir(), ".pi", "tasks");
@@ -94,23 +95,33 @@ export class TaskStore {
     }
   }
 
+  private toReducerState(): TaskReducerState {
+    return {
+      nextId: this.nextId,
+      tasksById: Object.fromEntries(this.tasks.entries()),
+    };
+  }
+
+  private applyReducerEvent(event: TaskReducerEvent): void {
+    const result = reduceTaskState(this.toReducerState(), event);
+    this.nextId = result.state.nextId;
+    this.tasks = new Map(Object.entries(result.state.tasksById));
+  }
+
   create(subject: string, description: string, metadata?: Record<string, unknown>): TaskEntry {
     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: TaskEntry = {
-        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))!;
     });
   }
 
@@ -129,21 +140,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 },
+        });
+      } 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,
+          },
+        });
       }
-      if (fields.subject !== undefined) entry.subject = fields.subject;
-      if (fields.description !== undefined) entry.description = fields.description;
-      entry.updatedAt = Date.now();
-      return entry;
+
+      return this.tasks.get(id);
     });
   }
 
   delete(id: string): boolean {
     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;
     });
   }
@@ -158,14 +214,15 @@ export class TaskStore {
 
   sweepCompleted(): number {
     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;
     });
   }
 }