@trevonistrevon/pi-loop 0.4.11 → 0.5.1

package/dist/runtime/monitor-ondone-runtime.js

@@ -0,0 +1,49 @@
+import { createCoordinator, } from "../coordinator.js";
+import { reduceMonitorCompletionEvent, } from "../monitor-completion-coordinator.js";
+export function createMonitorOnDoneRuntime(options) {
+    const { monitorManager, getLoop, deleteLoop, onLoopFire, debug } = options;
+    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 = getLoop(loopId);
+                if (!current)
+                    return;
+                debug?.(`onDone loop #${loopId} — monitor #${monitorId} completed, delivering through coordinator`);
+                onLoopFire(current);
+                deleteLoop(loopId);
+            },
+        },
+    });
+    function register(doneLoop, monitorId) {
+        const deliver = () => {
+            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)
+            return;
+        const monitor = monitorManager.get(monitorId);
+        if (monitor && monitor.status !== "running") {
+            if (monitor.status === "completed") {
+                deliver();
+                return;
+            }
+            debug?.(`onDone loop #${doneLoop.id} — monitor #${monitorId} already ${monitor.status}, expiring`);
+            deleteLoop(doneLoop.id);
+        }
+    }
+    return { register };
+}

package/dist/runtime/notification-runtime.d.ts

@@ -0,0 +1,34 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { Trigger } from "../types.js";
+export interface LoopFireEvent {
+    loopId: string;
+    prompt: string;
+    trigger: Trigger | string;
+    timestamp: number;
+    readOnly?: boolean;
+    recurring?: boolean;
+    autoTask?: boolean;
+}
+export interface PendingNotification extends LoopFireEvent {
+    key: string;
+    message: string;
+}
+export interface NotificationRuntimeOptions {
+    pi: ExtensionAPI;
+    hasPendingTasks: () => Promise<number>;
+    cleanDoneTasks: () => Promise<void>;
+    getHasPendingMessages: () => boolean;
+    debug?: (...args: unknown[]) => void;
+}
+export interface NotificationRuntime {
+    syncRuntimeState(options?: {
+        agentRunning?: boolean;
+        hasPendingMessages?: boolean;
+    }): void;
+    queueOrDeliverNotification(data: LoopFireEvent): Promise<void>;
+    flushPendingNotifications(options?: {
+        ignorePendingMessages?: boolean;
+    }): Promise<void>;
+    clear(reason: "session_shutdown" | "session_switch"): void;
+}
+export declare function createNotificationRuntime(options: NotificationRuntimeOptions): NotificationRuntime;

package/dist/runtime/notification-runtime.js

@@ -0,0 +1,152 @@
+import { createCoordinator, } from "../coordinator.js";
+import { reduceNotificationState, } from "../notification-reducer.js";
+export function createNotificationRuntime(options) {
+    const { pi, hasPendingTasks, cleanDoneTasks, getHasPendingMessages, debug } = options;
+    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);
+            },
+        },
+    });
+    function applyNotificationEvent(event) {
+        const result = reduceNotificationState(notificationState, event);
+        notificationState = result.state;
+        return result;
+    }
+    function syncRuntimeState(options) {
+        applyNotificationEvent({
+            type: "NOTIFICATION_RUNTIME_UPDATED",
+            at: Date.now(),
+            source: "system",
+            entityType: "notification",
+            payload: {
+                agentRunning: options?.agentRunning ?? notificationState.agentRunning,
+                hasPendingMessages: options?.hasPendingMessages ?? getHasPendingMessages(),
+            },
+        });
+    }
+    function buildLoopFireMessage(data) {
+        const triggerInfo = typeof data.trigger === "string"
+            ? data.trigger
+            : data.trigger?.type === "cron"
+                ? `schedule: ${data.trigger.schedule}`
+                : data.trigger?.type === "event"
+                    ? `event: ${data.trigger.source}`
+                    : "hybrid";
+        const loopId = data.loopId || "?";
+        const prompt = data.prompt || "loop fired";
+        const constraint = data.readOnly
+            ? "\n\nREAD-ONLY MODE — use only read tools (Read, TaskList, LoopList, MonitorList, etc.). No file writes, shell execution, or destructive changes."
+            : "";
+        return [
+            `[pi-loop] Loop #${loopId} fired (${triggerInfo}).${constraint}`,
+            prompt,
+        ].join("\n");
+    }
+    function buildPendingNotification(data) {
+        const key = data.recurring ? `loop:${data.loopId}` : `loop:${data.loopId}:${data.timestamp}`;
+        return {
+            ...data,
+            key,
+            message: buildLoopFireMessage(data),
+        };
+    }
+    async function deliverNotification(notification) {
+        if (notification.autoTask) {
+            const pending = await hasPendingTasks();
+            if (pending === 0) {
+                debug?.(`loop:fire #${notification.loopId} — no pending tasks at delivery time, dropping wake`);
+                await cleanDoneTasks();
+                return false;
+            }
+        }
+        syncRuntimeState({ agentRunning: true });
+        pi.sendMessage({
+            customType: "pi-loop",
+            content: notification.message,
+            display: false,
+            details: {
+                loopId: notification.loopId,
+                trigger: notification.trigger,
+                recurring: notification.recurring,
+                readOnly: notification.readOnly,
+                autoTask: notification.autoTask,
+                timestamp: notification.timestamp,
+            },
+        }, {
+            deliverAs: "steer",
+            triggerTurn: true,
+        });
+        return true;
+    }
+    async function flushPendingNotifications(options) {
+        if (flushPromise)
+            return flushPromise;
+        flushPromise = (async () => {
+            syncRuntimeState({ hasPendingMessages: getHasPendingMessages() });
+            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(() => {
+            flushPromise = undefined;
+        });
+        return flushPromise;
+    }
+    async function queueOrDeliverNotification(data) {
+        const notification = buildPendingNotification(data);
+        applyNotificationEvent({
+            type: "NOTIFICATION_QUEUED",
+            at: notification.timestamp,
+            source: "system",
+            entityType: "notification",
+            entityId: notification.key,
+            payload: { notification },
+        });
+        await flushPendingNotifications();
+    }
+    function clear(reason) {
+        syncRuntimeState({ agentRunning: false, hasPendingMessages: false });
+        applyNotificationEvent({
+            type: "NOTIFICATION_CLEARED",
+            at: Date.now(),
+            source: "session",
+            entityType: "notification",
+            payload: { reason },
+        });
+    }
+    return {
+        syncRuntimeState,
+        queueOrDeliverNotification,
+        flushPendingNotifications,
+        clear,
+    };
+}

package/dist/runtime/scope.d.ts

@@ -0,0 +1,8 @@
+export type LoopScope = "memory" | "session" | "project";
+export interface ScopeOptions {
+    piLoopEnv?: string;
+    loopScope: LoopScope;
+    cwd?: string;
+}
+export declare function resolveLoopStorePath(options: ScopeOptions, sessionId?: string): string | undefined;
+export declare function resolveTaskStorePath(options: ScopeOptions, sessionId?: string): string | undefined;

package/dist/runtime/scope.js

@@ -0,0 +1,33 @@
+import { join, resolve } from "node:path";
+export function resolveLoopStorePath(options, sessionId) {
+    const cwd = options.cwd ?? process.cwd();
+    const { piLoopEnv, loopScope } = options;
+    if (piLoopEnv === "off")
+        return undefined;
+    if (piLoopEnv?.startsWith("/"))
+        return piLoopEnv;
+    if (piLoopEnv?.startsWith("."))
+        return resolve(piLoopEnv);
+    if (piLoopEnv)
+        return piLoopEnv;
+    if (loopScope === "memory")
+        return undefined;
+    if (loopScope === "session" && sessionId) {
+        return join(cwd, ".pi", "loops", `loops-${sessionId}.json`);
+    }
+    if (loopScope === "session")
+        return undefined;
+    return join(cwd, ".pi", "loops", "loops.json");
+}
+export function resolveTaskStorePath(options, sessionId) {
+    const cwd = options.cwd ?? process.cwd();
+    const { loopScope } = options;
+    if (loopScope === "memory")
+        return undefined;
+    if (loopScope === "session" && sessionId) {
+        return join(cwd, ".pi", "tasks", `tasks-${sessionId}.json`);
+    }
+    if (loopScope === "session")
+        return undefined;
+    return join(cwd, ".pi", "tasks", "tasks.json");
+}

package/dist/runtime/session-runtime.d.ts

@@ -0,0 +1,39 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { LoopStore } from "../store.js";
+import type { NotificationRuntime } from "./notification-runtime.js";
+import type { LoopScope } from "./scope.js";
+export interface SessionSwitchEvent {
+    reason?: string;
+}
+export interface SessionRuntimeOptions {
+    pi: ExtensionAPI;
+    getLoopScope: () => LoopScope;
+    getPiLoopEnv: () => string | undefined;
+    recreateSessionStore: (sessionId: string) => void;
+    clearAllLoops: () => void;
+    getStore: () => LoopStore;
+    getScheduler: () => {
+        nextFire(id: string): number | undefined;
+        pump(now: number, filter?: (entry: {
+            id: string;
+        }) => boolean): void;
+    };
+    getTriggerSystem: () => {
+        start(): void;
+        stop(): void;
+    };
+    setLatestCtx: (ctx: ExtensionContext) => void;
+    setSessionId: (sessionId: string | undefined) => void;
+    widget: {
+        setUICtx(ui: ExtensionContext["ui"]): void;
+        update(): void;
+    };
+    notificationRuntime: NotificationRuntime;
+    flushPendingNotifications: (options?: {
+        ignorePendingMessages?: boolean;
+    }) => Promise<void>;
+    cleanupTaskBacklogLoops: () => Promise<number>;
+    hasPendingTasks: () => Promise<number>;
+    cleanDoneTasks: () => Promise<void>;
+}
+export declare function registerSessionRuntimeHooks(options: SessionRuntimeOptions): void;

package/dist/runtime/session-runtime.js

@@ -0,0 +1,110 @@
+export function registerSessionRuntimeHooks(options) {
+    const { pi, getLoopScope, getPiLoopEnv, recreateSessionStore, clearAllLoops, getStore, getScheduler, getTriggerSystem, setLatestCtx, setSessionId, widget, notificationRuntime, flushPendingNotifications, cleanupTaskBacklogLoops, hasPendingTasks, cleanDoneTasks, } = options;
+    let storeUpgraded = false;
+    let persistedShown = false;
+    function upgradeStoreIfNeeded(ctx) {
+        if (storeUpgraded)
+            return;
+        if (getLoopScope() === "session" && !getPiLoopEnv()) {
+            recreateSessionStore(ctx.sessionManager.getSessionId());
+        }
+        storeUpgraded = true;
+    }
+    function showPersistedLoops(_isResume = false) {
+        if (persistedShown)
+            return;
+        persistedShown = true;
+        const sessionStartedAt = Date.now();
+        const loops = getStore().list();
+        if (loops.length > 0) {
+            getStore().clearExpired();
+            getStore().expireEventLoops(sessionStartedAt);
+            getTriggerSystem().start();
+            widget.update();
+        }
+    }
+    async function pumpLoops() {
+        const pendingTasks = new Map();
+        for (const entry of getStore().list()) {
+            if (entry.status !== "active")
+                continue;
+            if (!entry.autoTask)
+                continue;
+            if (entry.trigger.type !== "cron" && entry.trigger.type !== "hybrid")
+                continue;
+            const nextFire = getScheduler().nextFire(entry.id);
+            if (!nextFire || Date.now() < nextFire)
+                continue;
+            const pending = await hasPendingTasks();
+            if (pending <= 0)
+                pendingTasks.set(entry.id, true);
+        }
+        getScheduler().pump(Date.now(), (entry) => !pendingTasks.has(entry.id));
+    }
+    pi.on("turn_start", async (_event, ctx) => {
+        setLatestCtx(ctx);
+        setSessionId(ctx.sessionManager.getSessionId());
+        widget.setUICtx(ctx.ui);
+        upgradeStoreIfNeeded(ctx);
+        widget.update();
+        await pumpLoops();
+    });
+    pi.on("before_agent_start", async (_event, ctx) => {
+        setLatestCtx(ctx);
+        widget.setUICtx(ctx.ui);
+        upgradeStoreIfNeeded(ctx);
+        showPersistedLoops();
+        widget.update();
+    });
+    pi.on("agent_start", async (_event, ctx) => {
+        notificationRuntime.syncRuntimeState({
+            agentRunning: true,
+            hasPendingMessages: ctx.hasPendingMessages(),
+        });
+        setLatestCtx(ctx);
+        widget.setUICtx(ctx.ui);
+    });
+    pi.on("agent_end", async (_event, ctx) => {
+        setLatestCtx(ctx);
+        widget.setUICtx(ctx.ui);
+        notificationRuntime.syncRuntimeState({
+            agentRunning: false,
+            hasPendingMessages: ctx.hasPendingMessages(),
+        });
+        await flushPendingNotifications({ ignorePendingMessages: true });
+        await cleanupTaskBacklogLoops();
+        await pumpLoops();
+    });
+    pi.on("session_shutdown", async () => {
+        notificationRuntime.clear("session_shutdown");
+    });
+    pi.on("session_switch", async (event, ctx) => {
+        setLatestCtx(ctx);
+        widget.setUICtx(ctx.ui);
+        getTriggerSystem().stop();
+        notificationRuntime.clear("session_switch");
+        setSessionId(undefined);
+        const isResume = event?.reason === "resume";
+        storeUpgraded = false;
+        persistedShown = false;
+        if (!isResume && getLoopScope() === "memory") {
+            clearAllLoops();
+        }
+        upgradeStoreIfNeeded(ctx);
+        showPersistedLoops(isResume);
+        widget.update();
+    });
+    pi.on("tool_execution_end", async (event, ctx) => {
+        setLatestCtx(ctx);
+        widget.setUICtx(ctx.ui);
+        const typed = event;
+        if (typed.toolName !== "bash" || typed.isError)
+            return;
+        const command = typed.args?.command ?? typed.input?.command;
+        if (typeof command !== "string")
+            return;
+        if (!/^\s*git\s+commit\b/i.test(command))
+            return;
+        await cleanDoneTasks();
+    });
+}

package/dist/runtime/task-backlog-runtime.d.ts

@@ -0,0 +1,36 @@
+import type { TaskStore } from "../task-store.js";
+import type { LoopEntry, Trigger } from "../types.js";
+export declare const AUTO_TASK_WORKER_THRESHOLD = 5;
+export declare const AUTO_TASK_WORKER_PROMPT = "Run TaskList, pick next pending task, mark it in_progress, implement it, run validation, complete it. If no pending tasks remain, call LoopDelete on your own loop ID.";
+export interface TaskBacklogRuntimeOptions {
+    getLoops: () => LoopEntry[];
+    createLoop: (trigger: Trigger, prompt: string, options: {
+        recurring: boolean;
+        taskBacklog?: boolean;
+        maxFires?: number;
+    }) => LoopEntry;
+    deleteLoop: (id: string) => void;
+    addTrigger: (entry: LoopEntry) => void;
+    removeTrigger: (id: string) => void;
+    updateWidget: () => void;
+    hasPendingTasks: () => Promise<number>;
+    bootstrapTaskLoop: (entry: LoopEntry) => Promise<boolean>;
+    triggerHasEventSource: (trigger: Trigger | string, source: string) => boolean;
+    debug?: (...args: unknown[]) => void;
+}
+export interface TaskBacklogRuntime {
+    cleanupTaskBacklogLoops(): Promise<number>;
+    ensureAutoTaskWorkerLoop(taskStore: TaskStore): Promise<{
+        entry?: LoopEntry;
+        created: boolean;
+    }>;
+    evaluateTaskBacklog(taskStore?: TaskStore, pendingCount?: number): Promise<{
+        entry?: LoopEntry;
+        created: boolean;
+        cleaned: number;
+    }>;
+    isAutoTaskWorkerLoop(entry: LoopEntry): boolean;
+    isTaskBacklogLoop(entry: LoopEntry): boolean;
+    findAutoTaskWorkerLoop(): LoopEntry | undefined;
+}
+export declare function createTaskBacklogRuntime(options: TaskBacklogRuntimeOptions): TaskBacklogRuntime;

package/dist/runtime/task-backlog-runtime.js

@@ -0,0 +1,105 @@
+import { createCoordinator, } from "../coordinator.js";
+import { reduceTaskBacklogEvent, } from "../task-backlog-coordinator.js";
+export const AUTO_TASK_WORKER_THRESHOLD = 5;
+export const AUTO_TASK_WORKER_PROMPT = "Run TaskList, pick next pending task, mark it in_progress, implement it, run validation, complete it. If no pending tasks remain, call LoopDelete on your own loop ID.";
+export function createTaskBacklogRuntime(options) {
+    const { getLoops, createLoop, deleteLoop, addTrigger, removeTrigger, updateWidget, hasPendingTasks, bootstrapTaskLoop, triggerHasEventSource, debug, } = options;
+    function isAutoTaskWorkerLoop(entry) {
+        return entry.status === "active"
+            && entry.prompt === AUTO_TASK_WORKER_PROMPT
+            && triggerHasEventSource(entry.trigger, "tasks:created");
+    }
+    function isTaskBacklogLoop(entry) {
+        return entry.status === "active"
+            && triggerHasEventSource(entry.trigger, "tasks:created")
+            && (entry.taskBacklog === true || isAutoTaskWorkerLoop(entry));
+    }
+    function findAutoTaskWorkerLoop() {
+        return getLoops().find(isAutoTaskWorkerLoop);
+    }
+    async function cleanupTaskBacklogLoops() {
+        const backlogLoops = getLoops().filter(isTaskBacklogLoop);
+        if (backlogLoops.length === 0)
+            return 0;
+        const pending = await hasPendingTasks();
+        if (pending < 0 || pending > 0)
+            return 0;
+        for (const entry of backlogLoops) {
+            debug?.(`task backlog loop #${entry.id} — no pending tasks remain, deleting`);
+            removeTrigger(entry.id);
+            deleteLoop(entry.id);
+        }
+        updateWidget();
+        return backlogLoops.length;
+    }
+    async function ensureAutoTaskWorkerLoop(taskStore) {
+        if (taskStore.pendingCount() < AUTO_TASK_WORKER_THRESHOLD)
+            return { created: false };
+        const existing = findAutoTaskWorkerLoop();
+        if (existing)
+            return { entry: existing, created: false };
+        const trigger = {
+            type: "hybrid",
+            cron: "*/5 * * * *",
+            event: { source: "tasks:created" },
+            debounceMs: 30000,
+        };
+        const entry = createLoop(trigger, AUTO_TASK_WORKER_PROMPT, {
+            recurring: true,
+            taskBacklog: true,
+            maxFires: 30,
+        });
+        addTrigger(entry);
+        await bootstrapTaskLoop(entry);
+        updateWidget();
+        return { entry, created: true };
+    }
+    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();
+            },
+        },
+    });
+    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,
+        };
+    }
+    return {
+        cleanupTaskBacklogLoops,
+        ensureAutoTaskWorkerLoop,
+        evaluateTaskBacklog,
+        isAutoTaskWorkerLoop,
+        isTaskBacklogLoop,
+        findAutoTaskWorkerLoop,
+    };
+}

package/dist/runtime/task-rpc.d.ts

@@ -0,0 +1,19 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { TaskStore } from "../task-store.js";
+import type { LoopEntry } from "../types.js";
+export interface TaskRuntimeBridgeOptions {
+    pi: ExtensionAPI;
+    isTasksAvailable: () => boolean;
+    setTasksAvailable: (available: boolean) => void;
+    getNativeTaskStore: () => TaskStore | undefined;
+    onNativeTaskCreated?: (taskStore: TaskStore) => void;
+    onNativeTasksPruned?: (taskStore: TaskStore) => Promise<void> | void;
+    debug?: (...args: unknown[]) => void;
+}
+export interface TaskRuntimeBridge {
+    checkTasksVersion(): void;
+    autoCreateTask(entry: LoopEntry): Promise<string | undefined>;
+    hasPendingTasks(): Promise<number>;
+    cleanDoneTasks(): Promise<void>;
+}
+export declare function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): TaskRuntimeBridge;