@trevonistrevon/pi-loop 0.1.0

package/dist/trigger-system.js

@@ -0,0 +1,130 @@
+export class TriggerSystem {
+    pi;
+    scheduler;
+    eventSubscriptions = new Map();
+    hybridTimers = new Map();
+    lastFireTime = new Map();
+    constructor(pi, scheduler) {
+        this.pi = pi;
+        this.scheduler = scheduler;
+    }
+    start() {
+        this.scheduler.start();
+    }
+    stop() {
+        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) {
+        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) {
+        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);
+    }
+    subscribeEvent(entry, source, filter) {
+        if (!this.eventSubscriptions.has(source)) {
+            this.eventSubscriptions.set(source, new Map());
+        }
+        const subs = this.eventSubscriptions.get(source);
+        const unsub = this.pi.events.on(source, (data) => {
+            if (entry.trigger.type === "hybrid") {
+                this.handleHybridFire(entry, data);
+            }
+            else {
+                if (this.matchesFilter(data, filter)) {
+                    this.fireLoop(entry);
+                }
+            }
+        });
+        subs.set(entry.id, unsub);
+    }
+    handleHybridFire(entry, _data) {
+        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);
+    }
+    fireLoop(entry) {
+        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(),
+        });
+    }
+    matchesFilter(data, filter) {
+        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/dist/types.d.ts

@@ -0,0 +1,54 @@
+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/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/widget.d.ts

@@ -0,0 +1,28 @@
+import type { MonitorManager } from "../monitor-manager.js";
+import type { CronScheduler } from "../scheduler.js";
+import type { LoopStore } from "../store.js";
+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 declare class LoopWidget {
+    private store;
+    private scheduler;
+    private monitorManager;
+    private uiCtx;
+    private tui;
+    private widgetRegistered;
+    private interval;
+    constructor(store: LoopStore, scheduler: CronScheduler | undefined, monitorManager: MonitorManager);
+    setUICtx(ctx: UICtx): void;
+    setStore(store: LoopStore): void;
+    setScheduler(scheduler: CronScheduler): void;
+    update(): void;
+    private renderWidget;
+    dispose(): void;
+}

package/dist/ui/widget.js

@@ -0,0 +1,114 @@
+import { truncateToWidth } from "@mariozechner/pi-tui";
+const MAX_VISIBLE = 6;
+export class LoopWidget {
+    store;
+    scheduler;
+    monitorManager;
+    uiCtx;
+    tui;
+    widgetRegistered = false;
+    interval;
+    constructor(store, scheduler, monitorManager) {
+        this.store = store;
+        this.scheduler = scheduler;
+        this.monitorManager = monitorManager;
+    }
+    setUICtx(ctx) {
+        this.uiCtx = ctx;
+    }
+    setStore(store) {
+        this.store = store;
+    }
+    setScheduler(scheduler) {
+        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();
+        }
+    }
+    renderWidget(tui, _theme) {
+        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) => truncateToWidth(line, w);
+        const lines = [];
+        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) {
+    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`;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@trevonistrevon/pi-loop",
+  "version": "0.1.0",
+  "description": "A pi extension for cron/event-based agent re-wake loops and background process monitoring.",
+  "author": "trevonistrevon",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/trevonistrevon/pi-loop.git"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "loop",
+    "cron",
+    "monitor",
+    "scheduler"
+  ],
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": ">=0.70.5",
+    "@mariozechner/pi-tui": ">=0.70.5"
+  },
+  "dependencies": {
+    "typebox": "^1.1.34"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run lint && npm run typecheck && npm run test && npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/ test/",
+    "lint:fix": "biome check --fix src/ test/"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.0",
+    "typescript": "^6.0.0",
+    "@biomejs/biome": "^2.4.13",
+    "vitest": "^4.1.5"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  }
+}