@trevonistrevon/pi-loop 0.4.10 → 0.5.0

package/dist/index.js

@@ -16,10 +16,14 @@
 import { randomUUID } from "node:crypto";
 import { join, resolve } from "node:path";
 import { Type } from "typebox";
+import { createCoordinator, } from "./coordinator.js";
 import { parseInterval } from "./loop-parse.js";
+import { reduceMonitorCompletionEvent, } from "./monitor-completion-coordinator.js";
 import { MonitorManager } from "./monitor-manager.js";
+import { reduceNotificationState, } from "./notification-reducer.js";
 import { CronScheduler } from "./scheduler.js";
 import { LoopStore } from "./store.js";
+import { reduceTaskBacklogEvent, } from "./task-backlog-coordinator.js";
 import { TaskStore } from "./task-store.js";
 import { TriggerSystem } from "./trigger-system.js";
 import { LoopWidget } from "./ui/widget.js";
@@ -183,12 +187,89 @@ export default function (pi) {
         if (nativeTaskStore) {
             nativeTaskStore.sweepCompleted();
             widget.update();
-            await cleanupTaskBacklogLoops();
+            await evaluateTaskBacklog(nativeTaskStore, nativeTaskStore.pendingCount());
         }
     }
-    let agentRunning = false;
-    const pendingNotifications = new Map();
+    let notificationState = {
+        notificationsByKey: {},
+        agentRunning: false,
+        hasPendingMessages: false,
+    };
     let flushPromise;
+    let notificationCoordinatorDelivered = false;
+    let notificationCoordinatorDeliveredSuccessfully = false;
+    const notificationReducerHandler = (incoming) => {
+        const result = reduceNotificationState(notificationState, incoming);
+        notificationState = result.state;
+        return result.effects;
+    };
+    const notificationCoordinator = createCoordinator({
+        reducers: [notificationReducerHandler],
+        effectHandlers: {
+            REQUEST_NOTIFICATION_FLUSH: () => { },
+            DELIVER_NOTIFICATION: async (effect) => {
+                notificationCoordinatorDelivered = true;
+                notificationCoordinatorDeliveredSuccessfully = await deliverNotification(effect.payload.notification);
+            },
+        },
+    });
+    const monitorCompletionReducerHandler = (incoming) => {
+        if (incoming.type !== "MONITOR_ONDONE_TRIGGERED")
+            return [];
+        return reduceMonitorCompletionEvent(incoming);
+    };
+    const monitorCompletionCoordinator = createCoordinator({
+        reducers: [monitorCompletionReducerHandler],
+        effectHandlers: {
+            DELIVER_MONITOR_ONDONE_WAKE: (effect) => {
+                const { loopId, monitorId } = effect.payload;
+                const current = store.get(loopId);
+                if (!current)
+                    return;
+                debug(`onDone loop #${loopId} — monitor #${monitorId} completed, delivering through coordinator`);
+                onLoopFire(current);
+                store.delete(loopId);
+            },
+        },
+    });
+    let taskBacklogCoordinatorStore;
+    let taskBacklogCoordinatorWorker = { created: false };
+    let taskBacklogCoordinatorCleanupCount = 0;
+    const taskBacklogReducerHandler = (incoming) => {
+        if (incoming.type !== "TASK_BACKLOG_EVALUATED")
+            return [];
+        return reduceTaskBacklogEvent(incoming);
+    };
+    const taskBacklogCoordinator = createCoordinator({
+        reducers: [taskBacklogReducerHandler],
+        effectHandlers: {
+            ENSURE_AUTO_TASK_WORKER: async () => {
+                if (!taskBacklogCoordinatorStore)
+                    return;
+                taskBacklogCoordinatorWorker = await ensureAutoTaskWorkerLoop(taskBacklogCoordinatorStore);
+            },
+            CLEANUP_TASK_BACKLOG_LOOPS: async () => {
+                taskBacklogCoordinatorCleanupCount = await cleanupTaskBacklogLoops();
+            },
+        },
+    });
+    function applyNotificationEvent(event) {
+        const result = reduceNotificationState(notificationState, event);
+        notificationState = result.state;
+        return result;
+    }
+    function syncNotificationRuntimeState(options) {
+        applyNotificationEvent({
+            type: "NOTIFICATION_RUNTIME_UPDATED",
+            at: Date.now(),
+            source: "system",
+            entityType: "notification",
+            payload: {
+                agentRunning: options?.agentRunning ?? notificationState.agentRunning,
+                hasPendingMessages: options?.hasPendingMessages ?? (_latestCtx?.hasPendingMessages() ?? false),
+            },
+        });
+    }
     function buildLoopFireMessage(data) {
         const triggerInfo = typeof data.trigger === "string"
             ? data.trigger
@@ -253,7 +334,7 @@ export default function (pi) {
                 return false;
             }
         }
-        agentRunning = true;
+        syncNotificationRuntimeState({ agentRunning: true });
         pi.sendMessage({
             customType: "pi-loop",
             content: notification.message,
@@ -276,16 +357,22 @@ export default function (pi) {
         if (flushPromise)
             return flushPromise;
         flushPromise = (async () => {
-            if (agentRunning)
-                return;
-            if (!options?.ignorePendingMessages && _latestCtx?.hasPendingMessages())
-                return;
-            const entries = [...pendingNotifications.entries()]
-                .sort(([, left], [, right]) => left.timestamp - right.timestamp);
-            for (const [key, notification] of entries) {
-                pendingNotifications.delete(key);
-                const delivered = await deliverNotification(notification);
-                if (delivered)
+            syncNotificationRuntimeState({
+                hasPendingMessages: _latestCtx?.hasPendingMessages() ?? false,
+            });
+            while (true) {
+                notificationCoordinatorDelivered = false;
+                notificationCoordinatorDeliveredSuccessfully = false;
+                await notificationCoordinator.dispatch({
+                    type: "NOTIFICATION_FLUSH_REQUESTED",
+                    at: Date.now(),
+                    source: "system",
+                    entityType: "notification",
+                    payload: { ignorePendingMessages: options?.ignorePendingMessages },
+                });
+                if (!notificationCoordinatorDelivered)
+                    return;
+                if (notificationCoordinatorDeliveredSuccessfully)
                     return;
             }
         })().finally(() => {
@@ -295,7 +382,14 @@ export default function (pi) {
     }
     async function queueOrDeliverNotification(data) {
         const notification = buildPendingNotification(data);
-        pendingNotifications.set(notification.key, notification);
+        applyNotificationEvent({
+            type: "NOTIFICATION_QUEUED",
+            at: notification.timestamp,
+            source: "system",
+            entityType: "notification",
+            entityId: notification.key,
+            payload: { notification },
+        });
         await flushPendingNotifications();
     }
     // ── Loop fire handler ──
@@ -370,28 +464,40 @@ export default function (pi) {
         widget.update();
     });
     pi.on("agent_start", async (_event, ctx) => {
-        agentRunning = true;
+        syncNotificationRuntimeState({ agentRunning: true, hasPendingMessages: ctx.hasPendingMessages() });
         _latestCtx = ctx;
         widget.setUICtx(ctx.ui);
     });
     pi.on("agent_end", async (_event, ctx) => {
-        agentRunning = false;
         _latestCtx = ctx;
         widget.setUICtx(ctx.ui);
+        syncNotificationRuntimeState({ agentRunning: false, hasPendingMessages: ctx.hasPendingMessages() });
         await flushPendingNotifications({ ignorePendingMessages: true });
         await cleanupTaskBacklogLoops();
         await pumpLoops();
     });
     pi.on("session_shutdown", async () => {
-        agentRunning = false;
-        pendingNotifications.clear();
+        syncNotificationRuntimeState({ agentRunning: false, hasPendingMessages: false });
+        applyNotificationEvent({
+            type: "NOTIFICATION_CLEARED",
+            at: Date.now(),
+            source: "session",
+            entityType: "notification",
+            payload: { reason: "session_shutdown" },
+        });
     });
     pi.on("session_switch", async (event, ctx) => {
         _latestCtx = ctx;
         widget.setUICtx(ctx.ui);
         triggerSystem.stop();
-        agentRunning = false;
-        pendingNotifications.clear();
+        syncNotificationRuntimeState({ agentRunning: false, hasPendingMessages: false });
+        applyNotificationEvent({
+            type: "NOTIFICATION_CLEARED",
+            at: Date.now(),
+            source: "session",
+            entityType: "notification",
+            payload: { reason: "session_switch" },
+        });
         _sessionId = undefined;
         const isResume = event?.reason === "resume";
         storeUpgraded = false;
@@ -403,6 +509,18 @@ export default function (pi) {
         showPersistedLoops(isResume);
         widget.update();
     });
+    pi.on("tool_execution_end", async (event, ctx) => {
+        _latestCtx = ctx;
+        widget.setUICtx(ctx.ui);
+        if (event?.toolName !== "bash" || event?.isError)
+            return;
+        const command = event?.args?.command ?? event?.input?.command;
+        if (typeof command !== "string")
+            return;
+        if (!/^\s*git\s+commit\b/i.test(command))
+            return;
+        await cleanDoneTasks();
+    });
     // ── Dynamic loop pump — fires cron/hybrid loops on idle instead of wall-clock timers ──
     async function pumpLoops() {
         const pendingTasks = new Map();
@@ -572,12 +690,14 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
     });
     function handleMonitorDoneLoop(doneLoop, monitorId) {
         const deliver = () => {
-            const current = store.get(doneLoop.id);
-            if (!current)
-                return;
-            debug(`onDone loop #${doneLoop.id} — monitor #${monitorId} completed, delivering directly`);
-            onLoopFire(current);
-            store.delete(doneLoop.id);
+            void monitorCompletionCoordinator.dispatch({
+                type: "MONITOR_ONDONE_TRIGGERED",
+                at: Date.now(),
+                source: "monitor",
+                entityType: "monitor",
+                entityId: monitorId,
+                payload: { loopId: doneLoop.id, monitorId },
+            });
         };
         const registered = monitorManager.onComplete(monitorId, deliver);
         if (registered)
@@ -1000,6 +1120,25 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
         widget.update();
         return { entry, created: true };
     }
+    async function evaluateTaskBacklog(taskStore, pendingCount) {
+        const resolvedPending = pendingCount ?? (taskStore ? taskStore.pendingCount() : await hasPendingTasks());
+        taskBacklogCoordinatorStore = taskStore;
+        taskBacklogCoordinatorWorker = { created: false };
+        taskBacklogCoordinatorCleanupCount = 0;
+        await taskBacklogCoordinator.dispatch({
+            type: "TASK_BACKLOG_EVALUATED",
+            at: Date.now(),
+            source: "system",
+            entityType: "task",
+            payload: { pendingCount: resolvedPending, threshold: AUTO_TASK_WORKER_THRESHOLD },
+        });
+        taskBacklogCoordinatorStore = undefined;
+        return {
+            entry: taskBacklogCoordinatorWorker.entry,
+            created: taskBacklogCoordinatorWorker.created,
+            cleaned: taskBacklogCoordinatorCleanupCount,
+        };
+    }
     async function createNativeTaskInteractively(ui) {
         if (!nativeTaskStore) {
             ui.notify("Native tasks are unavailable while pi-tasks is active", "warning");
@@ -1016,11 +1155,11 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
             description: entry.description,
             status: entry.status,
         });
-        const worker = await ensureAutoTaskWorkerLoop(nativeTaskStore);
+        const backlog = await evaluateTaskBacklog(nativeTaskStore, nativeTaskStore.pendingCount());
         widget.update();
         ui.notify(`Task #${entry.id} created`, "info");
-        if (worker.created && worker.entry) {
-            ui.notify(`Worker loop #${worker.entry.id} auto-created`, "info");
+        if (backlog.created && backlog.entry) {
+            ui.notify(`Worker loop #${backlog.entry.id} auto-created`, "info");
         }
     }
     async function viewNativeTasks(ui) {
@@ -1081,7 +1220,7 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
             ui.notify(`Task #${task.id} reopened`, "info");
         }
         widget.update();
-        await cleanupTaskBacklogLoops();
+        await evaluateTaskBacklog(nativeTaskStore, nativeTaskStore.pendingCount());
         return viewNativeTasks(ui);
     }
     // ── Native task tools (only when pi-tasks is absent) ──
@@ -1107,11 +1246,11 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
                         description: entry.description,
                         status: entry.status,
                     });
-                    const worker = await ensureAutoTaskWorkerLoop(nativeTaskStore);
+                    const backlog = await evaluateTaskBacklog(nativeTaskStore, nativeTaskStore.pendingCount());
                     widget.update();
                     ctx.ui.notify(`Task #${entry.id} created`, "info");
-                    if (worker.created && worker.entry) {
-                        ctx.ui.notify(`Worker loop #${worker.entry.id} auto-created`, "info");
+                    if (backlog.created && backlog.entry) {
+                        ctx.ui.notify(`Worker loop #${backlog.entry.id} auto-created`, "info");
                     }
                     return;
                 }
@@ -1144,10 +1283,10 @@ Fields:
                     description: entry.description,
                     status: entry.status,
                 });
-                const worker = await ensureAutoTaskWorkerLoop(taskStore);
+                const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
                 widget.update();
-                const autoLoopMsg = worker.created && worker.entry
-                    ? `\nWorker loop #${worker.entry.id} auto-created`
+                const autoLoopMsg = backlog.created && backlog.entry
+                    ? `\nWorker loop #${backlog.entry.id} auto-created`
                     : "";
                 return Promise.resolve(textResult(`Task #${entry.id} created: ${entry.subject}${autoLoopMsg}`));
             },
@@ -1204,9 +1343,12 @@ Parameters: id (required), status, subject, description`,
                 if (!entry)
                     return Promise.resolve(textResult(`Task #${id} not found`));
                 widget.update();
-                await cleanupTaskBacklogLoops();
+                const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
                 const statusMsg = status ? ` → ${status}` : "";
-                return Promise.resolve(textResult(`Task #${id} updated${statusMsg}`));
+                const autoLoopMsg = backlog.created && backlog.entry
+                    ? `\nWorker loop #${backlog.entry.id} auto-created`
+                    : "";
+                return Promise.resolve(textResult(`Task #${id} updated${statusMsg}${autoLoopMsg}`));
             },
         });
         pi.registerTool({
@@ -1220,7 +1362,7 @@ Parameters: id (required), status, subject, description`,
                 const deleted = taskStore.delete(params.id);
                 widget.update();
                 if (deleted) {
-                    await cleanupTaskBacklogLoops();
+                    await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
                     return Promise.resolve(textResult(`Task #${params.id} deleted`));
                 }
                 return Promise.resolve(textResult(`Task #${params.id} not found`));

package/dist/loop-reducer.d.ts

@@ -0,0 +1,63 @@
+import type { LoopEntry, Trigger } from "./types.js";
+export declare const MAX_LOOP_EXPIRY_MS: number;
+type ReducerSource = "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+export interface LoopReducerState {
+    nextId: number;
+    loopsById: Record<string, LoopEntry>;
+}
+export type LoopReducerEvent = {
+    type: "LOOP_CREATED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "loop";
+    entityId?: string;
+    payload: {
+        prompt: string;
+        trigger: Trigger;
+        recurring: boolean;
+        autoTask?: boolean;
+        taskBacklog?: boolean;
+        readOnly?: boolean;
+        maxFires?: number;
+    };
+} | {
+    type: "LOOP_PAUSED" | "LOOP_RESUMED" | "LOOP_FIRED" | "LOOP_DELETED" | "LOOP_MAX_FIRES_REACHED" | "LOOP_BACKLOG_EMPTY";
+    at: number;
+    source: ReducerSource;
+    entityType?: "loop";
+    entityId?: string;
+    payload: {
+        id: string;
+    };
+} | {
+    type: "LOOP_EXPIRED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "loop";
+    entityId?: string;
+    payload: {
+        id: string;
+        reason: "expires_at" | "resume_event_stale" | "already_completed_monitor";
+    };
+};
+export type LoopReducerEffect = {
+    type: "PERSIST_LOOP";
+    entityType: "loop";
+    entityId: string;
+    payload: {
+        loop: LoopEntry;
+    };
+} | {
+    type: "DELETE_LOOP";
+    entityType: "loop";
+    entityId: string;
+    payload: {
+        id: string;
+    };
+};
+export interface LoopReduceResult {
+    state: LoopReducerState;
+    effects: LoopReducerEffect[];
+}
+export declare function reduceLoopState(state: LoopReducerState, event: LoopReducerEvent): LoopReduceResult;
+export {};

package/dist/loop-reducer.js

@@ -0,0 +1,67 @@
+export const MAX_LOOP_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000;
+function cloneState(state) {
+    return {
+        nextId: state.nextId,
+        loopsById: { ...state.loopsById },
+    };
+}
+export function reduceLoopState(state, event) {
+    if (event.type === "LOOP_CREATED") {
+        const next = cloneState(state);
+        const id = String(next.nextId++);
+        const loop = {
+            id,
+            prompt: event.payload.prompt,
+            trigger: event.payload.trigger,
+            status: "active",
+            recurring: event.payload.recurring,
+            createdAt: event.at,
+            updatedAt: event.at,
+            expiresAt: event.at + MAX_LOOP_EXPIRY_MS,
+            autoTask: event.payload.autoTask,
+            taskBacklog: event.payload.taskBacklog,
+            readOnly: event.payload.readOnly,
+            maxFires: event.payload.maxFires,
+            fireCount: 0,
+        };
+        next.loopsById[id] = loop;
+        return {
+            state: next,
+            effects: [{ type: "PERSIST_LOOP", entityType: "loop", entityId: id, payload: { loop } }],
+        };
+    }
+    const id = event.payload.id;
+    const current = state.loopsById[id];
+    if (!current)
+        return { state, effects: [] };
+    if (event.type === "LOOP_DELETED"
+        || event.type === "LOOP_MAX_FIRES_REACHED"
+        || event.type === "LOOP_EXPIRED"
+        || event.type === "LOOP_BACKLOG_EMPTY") {
+        const next = cloneState(state);
+        delete next.loopsById[id];
+        return {
+            state: next,
+            effects: [{ type: "DELETE_LOOP", entityType: "loop", entityId: id, payload: { id } }],
+        };
+    }
+    const next = cloneState(state);
+    const loop = { ...current };
+    if (event.type === "LOOP_PAUSED") {
+        loop.status = "paused";
+        loop.updatedAt = event.at;
+    }
+    if (event.type === "LOOP_RESUMED") {
+        loop.status = "active";
+        loop.updatedAt = event.at;
+    }
+    if (event.type === "LOOP_FIRED") {
+        loop.fireCount = (loop.fireCount ?? 0) + 1;
+        loop.updatedAt = event.at;
+    }
+    next.loopsById[id] = loop;
+    return {
+        state: next,
+        effects: [{ type: "PERSIST_LOOP", entityType: "loop", entityId: id, payload: { loop } }],
+    };
+}

package/dist/monitor-completion-coordinator.d.ts

@@ -0,0 +1,10 @@
+import type { ReducerEffect, ReducerEvent } from "./coordinator.js";
+export type MonitorCompletionEvent = ReducerEvent<"MONITOR_ONDONE_TRIGGERED", {
+    loopId: string;
+    monitorId: string;
+}>;
+export type MonitorCompletionEffect = ReducerEffect<"DELIVER_MONITOR_ONDONE_WAKE", {
+    loopId: string;
+    monitorId: string;
+}>;
+export declare function reduceMonitorCompletionEvent(event: MonitorCompletionEvent): MonitorCompletionEffect[];

package/dist/monitor-completion-coordinator.js

@@ -0,0 +1,13 @@
+export function reduceMonitorCompletionEvent(event) {
+    if (event.type !== "MONITOR_ONDONE_TRIGGERED")
+        return [];
+    return [{
+            type: "DELIVER_MONITOR_ONDONE_WAKE",
+            entityType: "monitor",
+            entityId: event.payload.monitorId,
+            payload: {
+                loopId: event.payload.loopId,
+                monitorId: event.payload.monitorId,
+            },
+        }];
+}

package/dist/monitor-manager.d.ts

@@ -5,6 +5,8 @@ export declare class MonitorManager {
     private processes;
     private nextId;
     constructor(pi: ExtensionAPI);
+    private toReducerState;
+    private applyReducerEvent;
     create(command: string, description?: string, timeout?: number): MonitorEntry;
     get(id: string): MonitorEntry | undefined;
     list(): MonitorEntry[];