@trevonistrevon/pi-loop 0.4.11 → 0.5.1

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[];

package/dist/monitor-manager.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { reduceMonitorState, } from "./monitor-reducer.js";
 export class MonitorManager {
     pi;
     processes = new Map();
@@ -6,18 +7,41 @@ export class MonitorManager {
     constructor(pi) {
         this.pi = pi;
     }
-    create(command, description, timeout = 300000) {
-        const id = String(this.nextId++);
-        const entry = {
-            id,
-            command,
-            description,
-            timeout,
-            status: "running",
-            startedAt: Date.now(),
-            outputLines: 0,
-            outputBuffer: [],
+    toReducerState() {
+        return {
+            nextId: this.nextId,
+            monitorsById: Object.fromEntries(Array.from(this.processes.entries()).map(([id, process]) => [id, process.entry])),
         };
+    }
+    applyReducerEvent(event) {
+        const result = reduceMonitorState(this.toReducerState(), event);
+        this.nextId = result.state.nextId;
+        for (const [id, process] of [...this.processes.entries()]) {
+            const updated = result.state.monitorsById[id];
+            if (!updated) {
+                this.processes.delete(id);
+                continue;
+            }
+            process.entry = updated;
+        }
+        return result;
+    }
+    create(command, description, timeout = 300000) {
+        const now = Date.now();
+        const result = reduceMonitorState(this.toReducerState(), {
+            type: "MONITOR_CREATED",
+            at: now,
+            source: "tool",
+            entityType: "monitor",
+            payload: {
+                command,
+                description,
+                timeout,
+            },
+        });
+        this.nextId = result.state.nextId;
+        const id = String(this.nextId - 1);
+        const entry = result.state.monitorsById[id];
         const abortController = new AbortController();
         const child = spawn("sh", ["-c", command], {
             stdio: ["ignore", "pipe", "pipe"],
@@ -37,9 +61,14 @@ export class MonitorManager {
             for (const line of lines) {
                 if (line.length === 0)
                     continue;
-                entry.outputLines++;
-                if (entry.outputBuffer.length < 200)
-                    entry.outputBuffer.push(line);
+                this.applyReducerEvent({
+                    type: "MONITOR_OUTPUT",
+                    at: Date.now(),
+                    source: "monitor",
+                    entityType: "monitor",
+                    entityId: id,
+                    payload: { id, line },
+                });
                 this.pi.events.emit("monitor:output", {
                     monitorId: id,
                     line,
@@ -52,9 +81,14 @@ export class MonitorManager {
             for (const line of lines) {
                 if (line.length === 0)
                     continue;
-                entry.outputLines++;
-                if (entry.outputBuffer.length < 200)
-                    entry.outputBuffer.push(line);
+                this.applyReducerEvent({
+                    type: "MONITOR_OUTPUT",
+                    at: Date.now(),
+                    source: "monitor",
+                    entityType: "monitor",
+                    entityId: id,
+                    payload: { id, line },
+                });
                 this.pi.events.emit("monitor:output", {
                     monitorId: id,
                     line,
@@ -63,13 +97,22 @@ export class MonitorManager {
             }
         });
         const finish = (code, status) => {
-            entry.status = status;
-            entry.exitCode = code ?? undefined;
-            entry.completedAt = Date.now();
+            this.applyReducerEvent({
+                type: status === "completed" ? "MONITOR_COMPLETED" : "MONITOR_ERRORED",
+                at: Date.now(),
+                source: "monitor",
+                entityType: "monitor",
+                entityId: id,
+                payload: {
+                    id,
+                    exitCode: code ?? undefined,
+                },
+            });
+            const current = this.get(id);
             this.pi.events.emit(status === "completed" ? "monitor:done" : "monitor:error", {
                 monitorId: id,
                 exitCode: code,
-                outputLines: entry.outputLines,
+                outputLines: current.outputLines,
             });
             if (status === "completed") {
                 for (const callback of bp.completionCallbacks)
@@ -81,17 +124,35 @@ export class MonitorManager {
             bp.waiters = [];
             // Remove completed/errored monitors after a brief delay so tool
             // consumers have time to read the final state via MonitorList.
-            setTimeout(() => { this.processes.delete(id); }, 30000);
+            setTimeout(() => {
+                this.applyReducerEvent({
+                    type: "MONITOR_PRUNED",
+                    at: Date.now(),
+                    source: "system",
+                    entityType: "monitor",
+                    entityId: id,
+                    payload: { id },
+                });
+            }, 30000);
         };
         child.on("close", (code) => {
-            if (entry.status === "running") {
+            if (bp.entry.status === "running") {
                 finish(code, code === 0 ? "completed" : "error");
             }
         });
         child.on("error", (err) => {
-            if (entry.status === "running") {
-                entry.status = "error";
-                entry.completedAt = Date.now();
+            if (bp.entry.status === "running") {
+                this.applyReducerEvent({
+                    type: "MONITOR_ERRORED",
+                    at: Date.now(),
+                    source: "monitor",
+                    entityType: "monitor",
+                    entityId: id,
+                    payload: {
+                        id,
+                        error: err.message,
+                    },
+                });
                 this.pi.events.emit("monitor:error", {
                     monitorId: id,
                     error: err.message,
@@ -104,7 +165,7 @@ export class MonitorManager {
         });
         if (timeout > 0) {
             setTimeout(() => {
-                if (entry.status === "running") {
+                if (bp.entry.status === "running") {
                     this.stop(id);
                 }
             }, timeout);
@@ -125,7 +186,17 @@ export class MonitorManager {
         const bp = this.processes.get(id);
         if (!bp || bp.entry.status !== "running")
             return false;
-        bp.entry.status = "stopped";
+        this.applyReducerEvent({
+            type: "MONITOR_STOPPED",
+            at: Date.now(),
+            source: "tool",
+            entityType: "monitor",
+            entityId: id,
+            payload: {
+                id,
+                reason: "manual",
+            },
+        });
         bp.proc.kill("SIGTERM");
         await new Promise((resolve) => {
             const timer = setTimeout(() => {
@@ -140,7 +211,6 @@ export class MonitorManager {
                 resolve();
             });
         });
-        bp.entry.completedAt = Date.now();
         bp.completionCallbacks = [];
         for (const resolve of bp.waiters)
             resolve();
@@ -157,6 +227,14 @@ export class MonitorManager {
         }
         if (bp.entry.status !== "running")
             return false;
+        this.applyReducerEvent({
+            type: "MONITOR_ONDONE_REGISTERED",
+            at: Date.now(),
+            source: "tool",
+            entityType: "monitor",
+            entityId: id,
+            payload: { id },
+        });
         bp.completionCallbacks.push(callback);
         return true;
     }

package/dist/monitor-reducer.d.ts

@@ -0,0 +1,82 @@
+import type { MonitorEntry } from "./types.js";
+type ReducerSource = "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+export interface MonitorReducerEntry extends MonitorEntry {
+    onDoneRegistered?: boolean;
+}
+export interface MonitorReducerState {
+    nextId: number;
+    monitorsById: Record<string, MonitorReducerEntry>;
+}
+export type MonitorReducerEvent = {
+    type: "MONITOR_CREATED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "monitor";
+    entityId?: string;
+    payload: {
+        command: string;
+        description?: string;
+        timeout: number;
+    };
+} | {
+    type: "MONITOR_OUTPUT";
+    at: number;
+    source: ReducerSource;
+    entityType?: "monitor";
+    entityId?: string;
+    payload: {
+        id: string;
+        line: string;
+    };
+} | {
+    type: "MONITOR_COMPLETED" | "MONITOR_ERRORED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "monitor";
+    entityId?: string;
+    payload: {
+        id: string;
+        exitCode?: number;
+        error?: string;
+    };
+} | {
+    type: "MONITOR_STOPPED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "monitor";
+    entityId?: string;
+    payload: {
+        id: string;
+        reason: "manual" | "timeout";
+    };
+} | {
+    type: "MONITOR_PRUNED" | "MONITOR_ONDONE_REGISTERED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "monitor";
+    entityId?: string;
+    payload: {
+        id: string;
+    };
+};
+export type MonitorReducerEffect = {
+    type: "PERSIST_MONITOR";
+    entityType: "monitor";
+    entityId: string;
+    payload: {
+        monitor: MonitorReducerEntry;
+    };
+} | {
+    type: "DELETE_MONITOR";
+    entityType: "monitor";
+    entityId: string;
+    payload: {
+        id: string;
+    };
+};
+export interface MonitorReduceResult {
+    state: MonitorReducerState;
+    effects: MonitorReducerEffect[];
+}
+export declare function reduceMonitorState(state: MonitorReducerState, event: MonitorReducerEvent): MonitorReduceResult;
+export {};

package/dist/monitor-reducer.js

@@ -0,0 +1,69 @@
+function cloneState(state) {
+    return {
+        nextId: state.nextId,
+        monitorsById: { ...state.monitorsById },
+    };
+}
+export function reduceMonitorState(state, event) {
+    if (event.type === "MONITOR_CREATED") {
+        const next = cloneState(state);
+        const id = String(next.nextId++);
+        const monitor = {
+            id,
+            command: event.payload.command,
+            description: event.payload.description,
+            timeout: event.payload.timeout,
+            status: "running",
+            startedAt: event.at,
+            outputLines: 0,
+            outputBuffer: [],
+        };
+        next.monitorsById[id] = monitor;
+        return {
+            state: next,
+            effects: [{ type: "PERSIST_MONITOR", entityType: "monitor", entityId: id, payload: { monitor } }],
+        };
+    }
+    const id = event.payload.id;
+    const current = state.monitorsById[id];
+    if (!current)
+        return { state, effects: [] };
+    if (event.type === "MONITOR_PRUNED") {
+        const next = cloneState(state);
+        delete next.monitorsById[id];
+        return {
+            state: next,
+            effects: [{ type: "DELETE_MONITOR", entityType: "monitor", entityId: id, payload: { id } }],
+        };
+    }
+    const next = cloneState(state);
+    const monitor = { ...current };
+    if (event.type === "MONITOR_OUTPUT") {
+        monitor.outputLines++;
+        if (monitor.outputBuffer.length < 200)
+            monitor.outputBuffer = [...monitor.outputBuffer, event.payload.line];
+    }
+    if (event.type === "MONITOR_COMPLETED") {
+        monitor.status = "completed";
+        monitor.exitCode = event.payload.exitCode;
+        monitor.completedAt = event.at;
+    }
+    if (event.type === "MONITOR_ERRORED") {
+        monitor.status = "error";
+        if (event.payload.exitCode !== undefined)
+            monitor.exitCode = event.payload.exitCode;
+        monitor.completedAt = event.at;
+    }
+    if (event.type === "MONITOR_STOPPED") {
+        monitor.status = "stopped";
+        monitor.completedAt = event.at;
+    }
+    if (event.type === "MONITOR_ONDONE_REGISTERED") {
+        monitor.onDoneRegistered = true;
+    }
+    next.monitorsById[id] = monitor;
+    return {
+        state: next,
+        effects: [{ type: "PERSIST_MONITOR", entityType: "monitor", entityId: id, payload: { monitor } }],
+    };
+}

package/dist/notification-reducer.d.ts

@@ -0,0 +1,81 @@
+type ReducerSource = "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+export interface ReducerNotification {
+    key: string;
+    loopId: string;
+    message: string;
+    timestamp: number;
+    trigger: unknown;
+    recurring?: boolean;
+    autoTask?: boolean;
+    readOnly?: boolean;
+}
+export interface NotificationReducerState {
+    notificationsByKey: Record<string, ReducerNotification>;
+    agentRunning: boolean;
+    hasPendingMessages: boolean;
+}
+export type NotificationReducerEvent = {
+    type: "NOTIFICATION_QUEUED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "notification";
+    entityId?: string;
+    payload: {
+        notification: ReducerNotification;
+    };
+} | {
+    type: "NOTIFICATION_DROPPED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "notification";
+    entityId?: string;
+    payload: {
+        key: string;
+        reason: "zero_pending_tasks" | "session_switch" | "session_shutdown" | "superseded";
+    };
+} | {
+    type: "NOTIFICATION_CLEARED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "notification";
+    entityId?: string;
+    payload: {
+        reason: "session_switch" | "session_shutdown";
+    };
+} | {
+    type: "NOTIFICATION_FLUSH_REQUESTED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "notification";
+    entityId?: string;
+    payload: {
+        ignorePendingMessages?: boolean;
+    };
+} | {
+    type: "NOTIFICATION_RUNTIME_UPDATED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "notification";
+    entityId?: string;
+    payload: {
+        agentRunning: boolean;
+        hasPendingMessages: boolean;
+    };
+};
+export type NotificationReducerEffect = {
+    type: "REQUEST_NOTIFICATION_FLUSH";
+    payload: Record<string, never>;
+} | {
+    type: "DELIVER_NOTIFICATION";
+    entityType: "notification";
+    entityId: string;
+    payload: {
+        notification: ReducerNotification;
+    };
+};
+export interface NotificationReduceResult {
+    state: NotificationReducerState;
+    effects: NotificationReducerEffect[];
+}
+export declare function reduceNotificationState(state: NotificationReducerState, event: NotificationReducerEvent): NotificationReduceResult;
+export {};

package/dist/notification-reducer.js

@@ -0,0 +1,65 @@
+function cloneState(state) {
+    return {
+        notificationsByKey: { ...state.notificationsByKey },
+        agentRunning: state.agentRunning,
+        hasPendingMessages: state.hasPendingMessages,
+    };
+}
+export function reduceNotificationState(state, event) {
+    if (event.type === "NOTIFICATION_QUEUED") {
+        const next = cloneState(state);
+        next.notificationsByKey[event.payload.notification.key] = event.payload.notification;
+        return {
+            state: next,
+            effects: [{ type: "REQUEST_NOTIFICATION_FLUSH", payload: {} }],
+        };
+    }
+    if (event.type === "NOTIFICATION_DROPPED") {
+        const next = cloneState(state);
+        delete next.notificationsByKey[event.payload.key];
+        return { state: next, effects: [] };
+    }
+    if (event.type === "NOTIFICATION_CLEARED") {
+        return {
+            state: {
+                ...state,
+                notificationsByKey: {},
+            },
+            effects: [],
+        };
+    }
+    if (event.type === "NOTIFICATION_RUNTIME_UPDATED") {
+        return {
+            state: {
+                ...state,
+                agentRunning: event.payload.agentRunning,
+                hasPendingMessages: event.payload.hasPendingMessages,
+            },
+            effects: [],
+        };
+    }
+    if (event.type === "NOTIFICATION_FLUSH_REQUESTED") {
+        if (state.agentRunning)
+            return { state, effects: [] };
+        if (!event.payload.ignorePendingMessages && state.hasPendingMessages) {
+            return { state, effects: [] };
+        }
+        const queued = Object.values(state.notificationsByKey)
+            .sort((left, right) => left.timestamp - right.timestamp);
+        const nextNotification = queued[0];
+        if (!nextNotification)
+            return { state, effects: [] };
+        const next = cloneState(state);
+        delete next.notificationsByKey[nextNotification.key];
+        return {
+            state: next,
+            effects: [{
+                    type: "DELIVER_NOTIFICATION",
+                    entityType: "notification",
+                    entityId: nextNotification.key,
+                    payload: { notification: nextNotification },
+                }],
+        };
+    }
+    return { state, effects: [] };
+}

package/dist/runtime/monitor-ondone-runtime.d.ts

@@ -0,0 +1,13 @@
+import type { MonitorManager } from "../monitor-manager.js";
+import type { LoopEntry } from "../types.js";
+export interface MonitorOnDoneRuntimeOptions {
+    monitorManager: MonitorManager;
+    getLoop: (id: string) => LoopEntry | undefined;
+    deleteLoop: (id: string) => void;
+    onLoopFire: (entry: LoopEntry) => void;
+    debug?: (...args: unknown[]) => void;
+}
+export interface MonitorOnDoneRuntime {
+    register(doneLoop: LoopEntry, monitorId: string): void;
+}
+export declare function createMonitorOnDoneRuntime(options: MonitorOnDoneRuntimeOptions): MonitorOnDoneRuntime;