@trevonistrevon/pi-loop 0.1.0

package/src/trigger-system.ts

@@ -0,0 +1,132 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { CronScheduler } from "./scheduler.js";
+import type { LoopEntry } from "./types.js";
+
+export class TriggerSystem {
+  private eventSubscriptions = new Map<string, Map<string, () => void>>();
+  private hybridTimers = new Map<string, NodeJS.Timeout>();
+  private lastFireTime = new Map<string, number>();
+
+  constructor(
+    private pi: ExtensionAPI,
+    private scheduler: CronScheduler,
+  ) {}
+
+  start(): void {
+    this.scheduler.start();
+  }
+
+  stop(): void {
+    this.scheduler.stop();
+    for (const [_source, subs] of this.eventSubscriptions) {
+      for (const unsub of subs.values()) unsub();
+    }
+    this.eventSubscriptions.clear();
+    for (const timer of this.hybridTimers.values()) clearTimeout(timer);
+    this.hybridTimers.clear();
+  }
+
+  add(entry: LoopEntry): void {
+    if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
+      this.scheduler.add(entry);
+    }
+    if (entry.trigger.type === "event" || entry.trigger.type === "hybrid") {
+      const ev = entry.trigger.type === "hybrid" ? entry.trigger.event : entry.trigger;
+      this.subscribeEvent(entry, ev.source, ev.filter);
+    }
+  }
+
+  remove(id: string): void {
+    this.scheduler.remove(id);
+    for (const [source, subs] of this.eventSubscriptions) {
+      const unsub = subs.get(id);
+      if (unsub) { unsub(); subs.delete(id); }
+      if (subs.size === 0) this.eventSubscriptions.delete(source);
+    }
+    const timer = this.hybridTimers.get(id);
+    if (timer) { clearTimeout(timer); this.hybridTimers.delete(id); }
+    this.lastFireTime.delete(id);
+  }
+
+  private subscribeEvent(entry: LoopEntry, source: string, filter?: string): void {
+    if (!this.eventSubscriptions.has(source)) {
+      this.eventSubscriptions.set(source, new Map());
+    }
+    const subs = this.eventSubscriptions.get(source)!;
+
+    const unsub = this.pi.events.on(source as any, (data: any) => {
+      if (entry.trigger.type === "hybrid") {
+        this.handleHybridFire(entry, data);
+      } else {
+        if (this.matchesFilter(data, filter)) {
+          this.fireLoop(entry);
+        }
+      }
+    });
+
+    subs.set(entry.id, unsub);
+  }
+
+  private handleHybridFire(entry: LoopEntry, _data: any): void {
+    const now = Date.now();
+    const last = this.lastFireTime.get(entry.id) ?? 0;
+    const debounceMs = entry.trigger.type === "hybrid" ? entry.trigger.debounceMs : 0;
+
+    if (now - last < debounceMs) {
+      const existing = this.hybridTimers.get(entry.id);
+      if (existing) clearTimeout(existing);
+    }
+
+    const remaining = debounceMs - (now - last);
+    if (remaining <= 0) {
+      this.fireLoop(entry);
+      return;
+    }
+
+    const timer = setTimeout(() => {
+      this.hybridTimers.delete(entry.id);
+      this.fireLoop(entry);
+    }, remaining);
+
+    this.hybridTimers.set(entry.id, timer);
+  }
+
+  private fireLoop(entry: LoopEntry): void {
+    this.lastFireTime.set(entry.id, Date.now());
+    this.pi.events.emit("loop:fire", {
+      loopId: entry.id,
+      prompt: entry.prompt,
+      trigger: entry.trigger,
+      timestamp: Date.now(),
+    });
+  }
+
+  private matchesFilter(data: any, filter?: string): boolean {
+    if (!filter) return true;
+
+    if (filter.startsWith("regex:")) {
+      try {
+        const regex = new RegExp(filter.slice(6));
+        return regex.test(JSON.stringify(data));
+      } catch {
+        return false;
+      }
+    }
+
+    try {
+      const parsed = JSON.parse(filter);
+      for (const [key, value] of Object.entries(parsed)) {
+        const dataValue = data?.[key];
+        if (dataValue === undefined) return false;
+        if (typeof value === "object" && typeof dataValue === "object") {
+          if (JSON.stringify(value) !== JSON.stringify(dataValue)) return false;
+        } else if (String(dataValue) !== String(value)) {
+          return false;
+        }
+      }
+      return true;
+    } catch {
+      return true;
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,59 @@
+export type LoopStatus = "active" | "paused" | "expired";
+
+export interface CronTrigger {
+  type: "cron";
+  schedule: string;
+}
+
+export interface EventTrigger {
+  type: "event";
+  source: string;
+  filter?: string;
+}
+
+export interface HybridTrigger {
+  type: "hybrid";
+  cron: string;
+  event: { source: string; filter?: string };
+  debounceMs: number;
+}
+
+export type Trigger = CronTrigger | EventTrigger | HybridTrigger;
+
+export interface LoopEntry {
+  id: string;
+  prompt: string;
+  trigger: Trigger;
+  status: LoopStatus;
+  recurring: boolean;
+  createdAt: number;
+  updatedAt: number;
+  expiresAt: number;
+  autoTask?: boolean;
+  selfPaced?: boolean;
+}
+
+export interface LoopStoreData {
+  nextId: number;
+  loops: LoopEntry[];
+}
+
+export interface MonitorEntry {
+  id: string;
+  command: string;
+  description?: string;
+  timeout: number;
+  status: "running" | "completed" | "error" | "stopped";
+  startedAt: number;
+  completedAt?: number;
+  exitCode?: number;
+  outputLines: number;
+}
+
+export interface MonitorProcess {
+  entry: MonitorEntry;
+  pid: number;
+  proc: import("node:child_process").ChildProcess;
+  abortController: AbortController;
+  waiters: Array<() => void>;
+}

package/src/ui/widget.ts

@@ -0,0 +1,132 @@
+import { truncateToWidth } from "@mariozechner/pi-tui";
+import type { MonitorManager } from "../monitor-manager.js";
+import type { CronScheduler } from "../scheduler.js";
+import type { LoopStore } from "../store.js";
+
+const MAX_VISIBLE = 6;
+
+export type UICtx = {
+  setStatus(key: string, text: string | undefined): void;
+  setWidget(
+    key: string,
+    content: undefined | ((tui: any, theme: any) => { render(): string[]; invalidate(): void }),
+    options?: { placement?: "aboveEditor" | "belowEditor" },
+  ): void;
+};
+
+export class LoopWidget {
+  private uiCtx: UICtx | undefined;
+  private tui: any | undefined;
+  private widgetRegistered = false;
+  private interval: ReturnType<typeof setInterval> | undefined;
+
+  constructor(
+    private store: LoopStore,
+    private scheduler: CronScheduler | undefined,
+    private monitorManager: MonitorManager,
+  ) {}
+
+  setUICtx(ctx: UICtx) {
+    this.uiCtx = ctx;
+  }
+
+  setStore(store: LoopStore) {
+    this.store = store;
+  }
+
+  setScheduler(scheduler: CronScheduler) {
+    this.scheduler = scheduler;
+  }
+
+  update() {
+    if (!this.uiCtx) return;
+
+    const loops = this.store.list().filter(l => l.status === "active");
+    const monitors = this.monitorManager.list().filter(m => m.status === "running");
+
+    if (loops.length === 0 && monitors.length === 0) {
+      if (this.widgetRegistered) {
+        this.uiCtx.setWidget("loops", undefined);
+        this.widgetRegistered = false;
+      }
+      if (this.interval) {
+        clearInterval(this.interval);
+        this.interval = undefined;
+      }
+      return;
+    }
+
+    if (!this.interval) {
+      this.interval = setInterval(() => this.update(), 5000);
+    }
+
+    if (!this.widgetRegistered) {
+      this.uiCtx.setWidget("loops", (tui, theme) => {
+        this.tui = tui;
+        return { render: () => this.renderWidget(tui, theme), invalidate: () => {} };
+      }, { placement: "aboveEditor" });
+      this.widgetRegistered = true;
+    } else if (this.tui) {
+      this.tui.requestRender();
+    }
+  }
+
+  private renderWidget(tui: any, _theme: any): string[] {
+    const loops = this.store.list().filter(l => l.status === "active");
+    const monitors = this.monitorManager.list().filter(m => m.status === "running");
+    const w = tui.terminal.columns;
+    const trunc = (line: string) => truncateToWidth(line, w);
+
+    const lines: string[] = [];
+    const total = loops.length + monitors.length;
+
+    if (total === 0) return [];
+
+    lines.push(trunc(`⟳ ${loops.length} loops · ${monitors.length} monitors`));
+
+    for (const loop of loops.slice(0, MAX_VISIBLE)) {
+      const icon = "◷";
+      let schedule = "";
+      if (loop.trigger.type === "cron") {
+        schedule = loop.trigger.schedule;
+      } else if (loop.trigger.type === "event") {
+        schedule = `event: ${loop.trigger.source}`;
+      } else if (loop.trigger.type === "hybrid") {
+        schedule = `hybrid: ${loop.trigger.cron}`;
+      }
+      const nextFire = this.scheduler?.nextFire(loop.id);
+      let timing = "";
+      if (nextFire) {
+        const remaining = Math.max(0, nextFire - Date.now());
+        timing = ` (next: ${formatDuration(remaining)})`;
+      }
+      lines.push(trunc(`  ${icon} #${loop.id} ${loop.prompt.slice(0, 50)} → ${schedule}${timing}`));
+    }
+
+    for (const m of monitors.slice(0, Math.max(0, MAX_VISIBLE - loops.length))) {
+      const icon = "◉";
+      const age = Date.now() - m.startedAt;
+      lines.push(trunc(`  ${icon} #${m.id} ${m.command.slice(0, 40)} ${m.outputLines} lines (${formatDuration(age)})`));
+    }
+
+    return lines;
+  }
+
+  dispose() {
+    if (this.interval) { clearInterval(this.interval); this.interval = undefined; }
+    if (this.uiCtx) this.uiCtx.setWidget("loops", undefined);
+    this.widgetRegistered = false;
+    this.tui = undefined;
+  }
+}
+
+function formatDuration(ms: number): string {
+  const totalSec = Math.floor(ms / 1000);
+  if (totalSec < 60) return `${totalSec}s`;
+  const min = Math.floor(totalSec / 60);
+  const sec = totalSec % 60;
+  if (min < 60) return sec > 0 ? `${min}m ${sec}s` : `${min}m`;
+  const hr = Math.floor(min / 60);
+  const remMin = min % 60;
+  return remMin > 0 ? `${hr}h ${remMin}m` : `${hr}h`;
+}