@trevonistrevon/pi-loop 0.4.11 → 0.5.1

package/src/loop-reducer.ts

@@ -0,0 +1,148 @@
+import type { LoopEntry, Trigger } from "./types.js";
+
+export const MAX_LOOP_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000;
+
+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[];
+}
+
+function cloneState(state: LoopReducerState): LoopReducerState {
+  return {
+    nextId: state.nextId,
+    loopsById: { ...state.loopsById },
+  };
+}
+
+export function reduceLoopState(state: LoopReducerState, event: LoopReducerEvent): LoopReduceResult {
+  if (event.type === "LOOP_CREATED") {
+    const next = cloneState(state);
+    const id = String(next.nextId++);
+    const loop: LoopEntry = {
+      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: LoopEntry = { ...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/src/monitor-completion-coordinator.ts

@@ -0,0 +1,24 @@
+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 function reduceMonitorCompletionEvent(event: MonitorCompletionEvent): MonitorCompletionEffect[] {
+  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/src/monitor-manager.ts

@@ -1,6 +1,11 @@
 
 import { spawn } from "node:child_process";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  type MonitorReducerEvent,
+  type MonitorReducerState,
+  reduceMonitorState,
+} from "./monitor-reducer.js";
 import type { MonitorEntry, MonitorProcess } from "./types.js";
 
 export class MonitorManager {
@@ -9,18 +14,45 @@ export class MonitorManager {
 
   constructor(private pi: ExtensionAPI) {}
 
-  create(command: string, description?: string, timeout = 300000): MonitorEntry {
-    const id = String(this.nextId++);
-    const entry: MonitorEntry = {
-      id,
-      command,
-      description,
-      timeout,
-      status: "running",
-      startedAt: Date.now(),
-      outputLines: 0,
-      outputBuffer: [],
+  private toReducerState(): MonitorReducerState {
+    return {
+      nextId: this.nextId,
+      monitorsById: Object.fromEntries(
+        Array.from(this.processes.entries()).map(([id, process]) => [id, process.entry]),
+      ),
     };
+  }
+
+  private applyReducerEvent(event: MonitorReducerEvent) {
+    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: string, description?: string, timeout = 300000): MonitorEntry {
+    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], {
@@ -42,8 +74,14 @@ export class MonitorManager {
       const lines = data.toString().split("\n");
       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,
@@ -56,8 +94,14 @@ export class MonitorManager {
       const lines = data.toString().split("\n");
       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,
@@ -67,13 +111,22 @@ export class MonitorManager {
     });
 
     const finish = (code: number | null, status: "completed" | "error") => {
-      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) callback();
@@ -83,19 +136,37 @@ 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,
@@ -108,7 +179,7 @@ export class MonitorManager {
 
     if (timeout > 0) {
       setTimeout(() => {
-        if (entry.status === "running") {
+        if (bp.entry.status === "running") {
           this.stop(id);
         }
       }, timeout);
@@ -133,7 +204,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<void>((resolve) => {
@@ -148,7 +229,6 @@ export class MonitorManager {
       });
     });
 
-    bp.entry.completedAt = Date.now();
     bp.completionCallbacks = [];
     for (const resolve of bp.waiters) resolve();
     bp.waiters = [];
@@ -163,6 +243,14 @@ export class MonitorManager {
       return true;
     }
     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/src/monitor-reducer.ts

@@ -0,0 +1,166 @@
+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[];
+}
+
+function cloneState(state: MonitorReducerState): MonitorReducerState {
+  return {
+    nextId: state.nextId,
+    monitorsById: { ...state.monitorsById },
+  };
+}
+
+export function reduceMonitorState(state: MonitorReducerState, event: MonitorReducerEvent): MonitorReduceResult {
+  if (event.type === "MONITOR_CREATED") {
+    const next = cloneState(state);
+    const id = String(next.nextId++);
+    const monitor: MonitorReducerEntry = {
+      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: MonitorReducerEntry = { ...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/src/notification-reducer.ts

@@ -0,0 +1,155 @@
+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[];
+}
+
+function cloneState(state: NotificationReducerState): NotificationReducerState {
+  return {
+    notificationsByKey: { ...state.notificationsByKey },
+    agentRunning: state.agentRunning,
+    hasPendingMessages: state.hasPendingMessages,
+  };
+}
+
+export function reduceNotificationState(
+  state: NotificationReducerState,
+  event: NotificationReducerEvent,
+): NotificationReduceResult {
+  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: [] };
+}