@trevonistrevon/pi-loop 0.4.11 → 0.5.1

package/src/runtime/task-rpc.ts

@@ -0,0 +1,150 @@
+import { randomUUID } from "node:crypto";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { TaskStore } from "../task-store.js";
+import type { LoopEntry } from "../types.js";
+
+export interface TaskRuntimeBridgeOptions {
+  pi: ExtensionAPI;
+  isTasksAvailable: () => boolean;
+  setTasksAvailable: (available: boolean) => void;
+  getNativeTaskStore: () => TaskStore | undefined;
+  onNativeTaskCreated?: (taskStore: TaskStore) => void;
+  onNativeTasksPruned?: (taskStore: TaskStore) => Promise<void> | void;
+  debug?: (...args: unknown[]) => void;
+}
+
+export interface TaskRuntimeBridge {
+  checkTasksVersion(): void;
+  autoCreateTask(entry: LoopEntry): Promise<string | undefined>;
+  hasPendingTasks(): Promise<number>;
+  cleanDoneTasks(): Promise<void>;
+}
+
+export function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): TaskRuntimeBridge {
+  const {
+    pi,
+    isTasksAvailable,
+    setTasksAvailable,
+    getNativeTaskStore,
+    onNativeTaskCreated,
+    onNativeTasksPruned,
+    debug,
+  } = options;
+
+  function checkTasksVersion() {
+    const requestId = randomUUID();
+    const timer = setTimeout(() => {
+      unsub();
+    }, 5000);
+    const unsub = pi.events.on(`tasks:rpc:ping:reply:${requestId}`, (raw: unknown) => {
+      unsub();
+      clearTimeout(timer);
+      const remoteVersion = (raw as { data?: { version?: number } })?.data?.version;
+      if (remoteVersion !== undefined) setTasksAvailable(true);
+    });
+    pi.events.emit("tasks:rpc:ping", { requestId });
+  }
+
+  async function autoCreateTask(entry: LoopEntry): Promise<string | undefined> {
+    if (!entry.autoTask) return undefined;
+    if (isTasksAvailable()) {
+      try {
+        const requestId = randomUUID();
+        const taskId = await new Promise<string | undefined>((resolve) => {
+          const timer = setTimeout(() => {
+            unsub();
+            resolve(undefined);
+          }, 5000);
+          const unsub = pi.events.on(`tasks:rpc:create:reply:${requestId}`, (raw: unknown) => {
+            unsub();
+            clearTimeout(timer);
+            const reply = raw as { success: boolean; data?: { id: string } };
+            if (reply.success && reply.data) resolve(reply.data.id);
+            else resolve(undefined);
+          });
+          pi.events.emit("tasks:rpc:create", {
+            requestId,
+            subject: entry.prompt.slice(0, 80),
+            description: `Auto-created from loop #${entry.id}`,
+            metadata: { loopId: entry.id, trigger: entry.trigger },
+          });
+        });
+        return taskId;
+      } catch {
+        return undefined;
+      }
+    }
+
+    const nativeTaskStore = getNativeTaskStore();
+    if (!nativeTaskStore) return undefined;
+    const task = nativeTaskStore.create(
+      entry.prompt.slice(0, 80),
+      `Auto-created from loop #${entry.id}`,
+      { loopId: entry.id, trigger: entry.trigger },
+    );
+    onNativeTaskCreated?.(nativeTaskStore);
+    return task.id;
+  }
+
+  async function hasPendingTasks(): Promise<number> {
+    if (isTasksAvailable()) {
+      try {
+        const requestId = randomUUID();
+        const count = await new Promise<number>((resolve) => {
+          const timer = setTimeout(() => {
+            unsub();
+            resolve(-1);
+          }, 3000);
+          const unsub = pi.events.on(`tasks:rpc:pending:reply:${requestId}`, (raw: unknown) => {
+            unsub();
+            clearTimeout(timer);
+            const reply = raw as { success: boolean; data?: { pending: number } };
+            resolve(reply.success && reply.data ? reply.data.pending : -1);
+          });
+          pi.events.emit("tasks:rpc:pending", { requestId });
+        });
+        return count;
+      } catch {
+        return -1;
+      }
+    }
+
+    return getNativeTaskStore()?.pendingCount() ?? -1;
+  }
+
+  async function cleanDoneTasks(): Promise<void> {
+    if (isTasksAvailable()) {
+      try {
+        const requestId = randomUUID();
+        await new Promise<void>((resolve) => {
+          const timer = setTimeout(() => {
+            unsub();
+            resolve();
+          }, 3000);
+          const unsub = pi.events.on(`tasks:rpc:clean:reply:${requestId}`, () => {
+            unsub();
+            clearTimeout(timer);
+            debug?.("tasks:rpc:clean — done tasks swept");
+            resolve();
+          });
+          pi.events.emit("tasks:rpc:clean", { requestId });
+        });
+      } catch {
+        // timeout or error, ignore
+      }
+      return;
+    }
+
+    const nativeTaskStore = getNativeTaskStore();
+    if (!nativeTaskStore) return;
+    nativeTaskStore.pruneCompleted();
+    await onNativeTasksPruned?.(nativeTaskStore);
+  }
+
+  return {
+    checkTasksVersion,
+    autoCreateTask,
+    hasPendingTasks,
+    cleanDoneTasks,
+  };
+}

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 { LoopEntry, LoopStatus, LoopStoreData, Trigger } from "./types.js";
+import { type LoopReducerEvent, type LoopReducerState, reduceLoopState } from "./loop-reducer.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;
-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))!;
     });
   }
 
@@ -131,37 +143,89 @@ export class LoopStore {
     return Array.from(this.loops.values()).sort((a, b) => Number(a.id) - Number(b.id));
   }
 
-  update(id: string, fields: { status?: LoopStatus; trigger?: Trigger; prompt?: string; fireCount?: number }): { entry: LoopEntry | undefined; changedFields: string[] } {
+  pause(id: string): LoopEntry | undefined {
+    return this.withLock(() => {
+      const entry = this.loops.get(id);
+      if (!entry) return undefined;
+      this.applyReducerEvent({
+        type: "LOOP_PAUSED",
+        at: Date.now(),
+        source: "tool",
+        entityType: "loop",
+        entityId: id,
+        payload: { id },
+      });
+      return this.loops.get(id);
+    });
+  }
+
+  resume(id: string): LoopEntry | undefined {
+    return this.withLock(() => {
+      const entry = this.loops.get(id);
+      if (!entry) return undefined;
+      this.applyReducerEvent({
+        type: "LOOP_RESUMED",
+        at: Date.now(),
+        source: "tool",
+        entityType: "loop",
+        entityId: id,
+        payload: { id },
+      });
+      return this.loops.get(id);
+    });
+  }
+
+  fire(id: string): LoopEntry | undefined {
     return this.withLock(() => {
       const entry = this.loops.get(id);
-      if (!entry) return { entry: undefined, changedFields: [] };
+      if (!entry) return undefined;
+      this.applyReducerEvent({
+        type: "LOOP_FIRED",
+        at: Date.now(),
+        source: "system",
+        entityType: "loop",
+        entityId: id,
+        payload: { id },
+      });
+      return this.loops.get(id);
+    });
+  }
+
+  updateMetadata(id: string, fields: { trigger?: Trigger; prompt?: string }): { entry: LoopEntry | undefined; changedFields: string[] } {
+    return this.withLock(() => {
+      const current = this.loops.get(id);
+      if (!current) return { entry: undefined, changedFields: [] };
 
       const changedFields: string[] = [];
-      if (fields.status !== undefined) {
-        entry.status = fields.status;
-        changedFields.push("status");
-      }
+      const now = Date.now();
+
       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;
-        changedFields.push("fireCount");
+      if (changedFields.length > 0) {
+        current.updatedAt = now;
       }
-      entry.updatedAt = Date.now();
-      return { entry, changedFields };
+
+      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 +234,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 +253,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 } }],
+  };
+}