@trevonistrevon/pi-loop 0.4.11 → 0.5.1

package/dist/runtime/task-rpc.js

@@ -0,0 +1,118 @@
+import { randomUUID } from "node:crypto";
+export function createTaskRuntimeBridge(options) {
+    const { pi, isTasksAvailable, setTasksAvailable, getNativeTaskStore, onNativeTaskCreated, onNativeTasksPruned, debug, } = options;
+    function checkTasksVersion() {
+        const requestId = randomUUID();
+        const timer = setTimeout(() => {
+            unsub();
+        }, 5000);
+        const unsub = pi.events.on(`tasks:rpc:ping:reply:${requestId}`, (raw) => {
+            unsub();
+            clearTimeout(timer);
+            const remoteVersion = raw?.data?.version;
+            if (remoteVersion !== undefined)
+                setTasksAvailable(true);
+        });
+        pi.events.emit("tasks:rpc:ping", { requestId });
+    }
+    async function autoCreateTask(entry) {
+        if (!entry.autoTask)
+            return undefined;
+        if (isTasksAvailable()) {
+            try {
+                const requestId = randomUUID();
+                const taskId = await new Promise((resolve) => {
+                    const timer = setTimeout(() => {
+                        unsub();
+                        resolve(undefined);
+                    }, 5000);
+                    const unsub = pi.events.on(`tasks:rpc:create:reply:${requestId}`, (raw) => {
+                        unsub();
+                        clearTimeout(timer);
+                        const reply = raw;
+                        if (reply.success && reply.data)
+                            resolve(reply.data.id);
+                        else
+                            resolve(undefined);
+                    });
+                    pi.events.emit("tasks:rpc:create", {
+                        requestId,
+                        subject: entry.prompt.slice(0, 80),
+                        description: `Auto-created from loop #${entry.id}`,
+                        metadata: { loopId: entry.id, trigger: entry.trigger },
+                    });
+                });
+                return taskId;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const nativeTaskStore = getNativeTaskStore();
+        if (!nativeTaskStore)
+            return undefined;
+        const task = nativeTaskStore.create(entry.prompt.slice(0, 80), `Auto-created from loop #${entry.id}`, { loopId: entry.id, trigger: entry.trigger });
+        onNativeTaskCreated?.(nativeTaskStore);
+        return task.id;
+    }
+    async function hasPendingTasks() {
+        if (isTasksAvailable()) {
+            try {
+                const requestId = randomUUID();
+                const count = await new Promise((resolve) => {
+                    const timer = setTimeout(() => {
+                        unsub();
+                        resolve(-1);
+                    }, 3000);
+                    const unsub = pi.events.on(`tasks:rpc:pending:reply:${requestId}`, (raw) => {
+                        unsub();
+                        clearTimeout(timer);
+                        const reply = raw;
+                        resolve(reply.success && reply.data ? reply.data.pending : -1);
+                    });
+                    pi.events.emit("tasks:rpc:pending", { requestId });
+                });
+                return count;
+            }
+            catch {
+                return -1;
+            }
+        }
+        return getNativeTaskStore()?.pendingCount() ?? -1;
+    }
+    async function cleanDoneTasks() {
+        if (isTasksAvailable()) {
+            try {
+                const requestId = randomUUID();
+                await new Promise((resolve) => {
+                    const timer = setTimeout(() => {
+                        unsub();
+                        resolve();
+                    }, 3000);
+                    const unsub = pi.events.on(`tasks:rpc:clean:reply:${requestId}`, () => {
+                        unsub();
+                        clearTimeout(timer);
+                        debug?.("tasks:rpc:clean — done tasks swept");
+                        resolve();
+                    });
+                    pi.events.emit("tasks:rpc:clean", { requestId });
+                });
+            }
+            catch {
+                // timeout or error, ignore
+            }
+            return;
+        }
+        const nativeTaskStore = getNativeTaskStore();
+        if (!nativeTaskStore)
+            return;
+        nativeTaskStore.pruneCompleted();
+        await onNativeTasksPruned?.(nativeTaskStore);
+    }
+    return {
+        checkTasksVersion,
+        autoCreateTask,
+        hasPendingTasks,
+        cleanDoneTasks,
+    };
+}

package/dist/store.d.ts

@@ -1,4 +1,4 @@
-import type { LoopEntry, LoopStatus, Trigger } from "./types.js";
+import type { LoopEntry, Trigger } from "./types.js";
 export declare class LoopStore {
     private filePath;
     private lockPath;
@@ -8,6 +8,8 @@ export declare class LoopStore {
     private load;
     private save;
     private withLock;
+    private toReducerState;
+    private applyReducerEvent;
     create(trigger: Trigger, prompt: string, opts: {
         recurring: boolean;
         autoTask?: boolean;
@@ -17,11 +19,12 @@ export declare class LoopStore {
     }): LoopEntry;
     get(id: string): LoopEntry | undefined;
     list(): LoopEntry[];
-    update(id: string, fields: {
-        status?: LoopStatus;
+    pause(id: string): LoopEntry | undefined;
+    resume(id: string): LoopEntry | undefined;
+    fire(id: string): LoopEntry | undefined;
+    updateMetadata(id: string, fields: {
         trigger?: Trigger;
         prompt?: string;
-        fireCount?: number;
     }): {
         entry: LoopEntry | undefined;
         changedFields: string[];

package/dist/store.js

@@ -1,11 +1,11 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
+import { reduceLoopState } from "./loop-reducer.js";
 const LOOPS_DIR = join(homedir(), ".pi", "loops");
 const LOCK_RETRY_MS = 50;
 const LOCK_MAX_RETRIES = 100;
 const MAX_LOOPS = 25;
-const MAX_EXPIRY_DAYS = 7;
 function acquireLock(lockPath) {
     for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
         try {
@@ -104,29 +104,39 @@ export class LoopStore {
             releaseLock(this.lockPath);
         }
     }
+    toReducerState() {
+        return {
+            nextId: this.nextId,
+            loopsById: Object.fromEntries(this.loops.entries()),
+        };
+    }
+    applyReducerEvent(event) {
+        const result = reduceLoopState(this.toReducerState(), event);
+        this.nextId = result.state.nextId;
+        this.loops = new Map(Object.entries(result.state.loopsById));
+    }
     create(trigger, prompt, opts) {
         return this.withLock(() => {
             if (this.loops.size >= MAX_LOOPS) {
                 throw new Error(`Maximum of ${MAX_LOOPS} loops reached. Delete some before creating new ones.`);
             }
             const now = Date.now();
-            const entry = {
-                id: String(this.nextId++),
-                prompt,
-                trigger,
-                status: "active",
-                recurring: opts.recurring,
-                autoTask: opts.autoTask,
-                taskBacklog: opts.taskBacklog,
-                readOnly: opts.readOnly,
-                maxFires: opts.maxFires,
-                fireCount: 0,
-                createdAt: now,
-                updatedAt: now,
-                expiresAt: now + MAX_EXPIRY_DAYS * 24 * 60 * 60 * 1000,
-            };
-            this.loops.set(entry.id, entry);
-            return entry;
+            this.applyReducerEvent({
+                type: "LOOP_CREATED",
+                at: now,
+                source: "tool",
+                entityType: "loop",
+                payload: {
+                    prompt,
+                    trigger,
+                    recurring: opts.recurring,
+                    autoTask: opts.autoTask,
+                    taskBacklog: opts.taskBacklog,
+                    readOnly: opts.readOnly,
+                    maxFires: opts.maxFires,
+                },
+            });
+            return this.loops.get(String(this.nextId - 1));
         });
     }
     get(id) {
@@ -139,37 +149,87 @@ export class LoopStore {
             this.load();
         return Array.from(this.loops.values()).sort((a, b) => Number(a.id) - Number(b.id));
     }
-    update(id, fields) {
+    pause(id) {
+        return this.withLock(() => {
+            const entry = this.loops.get(id);
+            if (!entry)
+                return undefined;
+            this.applyReducerEvent({
+                type: "LOOP_PAUSED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "loop",
+                entityId: id,
+                payload: { id },
+            });
+            return this.loops.get(id);
+        });
+    }
+    resume(id) {
+        return this.withLock(() => {
+            const entry = this.loops.get(id);
+            if (!entry)
+                return undefined;
+            this.applyReducerEvent({
+                type: "LOOP_RESUMED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "loop",
+                entityId: id,
+                payload: { id },
+            });
+            return this.loops.get(id);
+        });
+    }
+    fire(id) {
         return this.withLock(() => {
             const entry = this.loops.get(id);
             if (!entry)
+                return undefined;
+            this.applyReducerEvent({
+                type: "LOOP_FIRED",
+                at: Date.now(),
+                source: "system",
+                entityType: "loop",
+                entityId: id,
+                payload: { id },
+            });
+            return this.loops.get(id);
+        });
+    }
+    updateMetadata(id, fields) {
+        return this.withLock(() => {
+            const current = this.loops.get(id);
+            if (!current)
                 return { entry: undefined, changedFields: [] };
             const changedFields = [];
-            if (fields.status !== undefined) {
-                entry.status = fields.status;
-                changedFields.push("status");
-            }
+            const now = Date.now();
             if (fields.trigger !== undefined) {
-                entry.trigger = fields.trigger;
+                current.trigger = fields.trigger;
                 changedFields.push("trigger");
             }
             if (fields.prompt !== undefined) {
-                entry.prompt = fields.prompt;
+                current.prompt = fields.prompt;
                 changedFields.push("prompt");
             }
-            if (fields.fireCount !== undefined) {
-                entry.fireCount = fields.fireCount;
-                changedFields.push("fireCount");
+            if (changedFields.length > 0) {
+                current.updatedAt = now;
             }
-            entry.updatedAt = Date.now();
-            return { entry, changedFields };
+            return { entry: this.loops.get(id), changedFields };
         });
     }
     delete(id) {
         return this.withLock(() => {
             if (!this.loops.has(id))
                 return false;
-            this.loops.delete(id);
+            this.applyReducerEvent({
+                type: "LOOP_DELETED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "loop",
+                entityId: id,
+                payload: { id },
+            });
             return true;
         });
     }
@@ -177,11 +237,18 @@ export class LoopStore {
         return this.withLock(() => {
             const now = Date.now();
             let count = 0;
-            for (const [id, entry] of this.loops) {
-                if (now >= entry.expiresAt) {
-                    this.loops.delete(id);
-                    count++;
-                }
+            for (const [id, entry] of [...this.loops.entries()]) {
+                if (now < entry.expiresAt)
+                    continue;
+                this.applyReducerEvent({
+                    type: "LOOP_EXPIRED",
+                    at: now,
+                    source: "system",
+                    entityType: "loop",
+                    entityId: id,
+                    payload: { id, reason: "expires_at" },
+                });
+                count++;
             }
             return count;
         });
@@ -189,27 +256,40 @@ export class LoopStore {
     expireEventLoops(sessionStartedAt) {
         return this.withLock(() => {
             let count = 0;
-            const toDelete = [];
-            for (const [id, entry] of this.loops) {
+            for (const [id, entry] of [...this.loops.entries()]) {
                 if (entry.status !== "active")
                     continue;
-                if (entry.trigger.type === "event" || entry.trigger.type === "hybrid") {
-                    if (entry.createdAt < sessionStartedAt) {
-                        toDelete.push(id);
-                        count++;
-                    }
-                }
+                if (entry.trigger.type !== "event" && entry.trigger.type !== "hybrid")
+                    continue;
+                if (entry.createdAt >= sessionStartedAt)
+                    continue;
+                this.applyReducerEvent({
+                    type: "LOOP_EXPIRED",
+                    at: sessionStartedAt,
+                    source: "session",
+                    entityType: "loop",
+                    entityId: id,
+                    payload: { id, reason: "resume_event_stale" },
+                });
+                count++;
             }
-            for (const id of toDelete)
-                this.loops.delete(id);
             return count;
         });
     }
     clearAll() {
         return this.withLock(() => {
-            const count = this.loops.size;
-            this.loops.clear();
-            return count;
+            const ids = [...this.loops.keys()];
+            for (const id of ids) {
+                this.applyReducerEvent({
+                    type: "LOOP_DELETED",
+                    at: Date.now(),
+                    source: "system",
+                    entityType: "loop",
+                    entityId: id,
+                    payload: { id },
+                });
+            }
+            return ids.length;
         });
     }
     deleteFileIfEmpty() {

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

@@ -0,0 +1,12 @@
+import type { ReducerEffect, ReducerEvent } from "./coordinator.js";
+export type TaskBacklogEvent = ReducerEvent<"TASK_BACKLOG_EVALUATED", {
+    pendingCount: number;
+    threshold: number;
+}>;
+export type TaskBacklogEffect = ReducerEffect<"ENSURE_AUTO_TASK_WORKER", {
+    pendingCount: number;
+    threshold: number;
+}> | ReducerEffect<"CLEANUP_TASK_BACKLOG_LOOPS", {
+    pendingCount: number;
+}>;
+export declare function reduceTaskBacklogEvent(event: TaskBacklogEvent): TaskBacklogEffect[];

package/dist/task-backlog-coordinator.js

@@ -0,0 +1,22 @@
+export function reduceTaskBacklogEvent(event) {
+    if (event.type !== "TASK_BACKLOG_EVALUATED")
+        return [];
+    const { pendingCount, threshold } = event.payload;
+    if (pendingCount < 0)
+        return [];
+    if (pendingCount === 0) {
+        return [{
+                type: "CLEANUP_TASK_BACKLOG_LOOPS",
+                entityType: "task",
+                payload: { pendingCount },
+            }];
+    }
+    if (pendingCount >= threshold) {
+        return [{
+                type: "ENSURE_AUTO_TASK_WORKER",
+                entityType: "task",
+                payload: { pendingCount, threshold },
+            }];
+    }
+    return [];
+}

package/dist/task-reducer.d.ts

@@ -0,0 +1,66 @@
+import type { TaskEntry } from "./task-types.js";
+export interface TaskReducerState {
+    nextId: number;
+    tasksById: Record<string, TaskEntry>;
+}
+export type TaskReducerEvent = {
+    type: "TASK_CREATED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "task";
+    entityId?: string;
+    payload: {
+        subject: string;
+        description: string;
+        metadata?: Record<string, unknown>;
+    };
+} | {
+    type: "TASK_STARTED" | "TASK_COMPLETED" | "TASK_REOPENED" | "TASK_DELETED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "task";
+    entityId?: string;
+    payload: {
+        id: string;
+    };
+} | {
+    type: "TASK_UPDATED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "task";
+    entityId?: string;
+    payload: {
+        id: string;
+        subject?: string;
+        description?: string;
+    };
+} | {
+    type: "TASKS_PRUNED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "task";
+    entityId?: string;
+    payload: {
+        reason: "git_commit" | "zero_pending_cleanup" | "manual";
+    };
+};
+export type TaskReducerEffect = {
+    type: "PERSIST_TASK";
+    entityType: "task";
+    entityId: string;
+    payload: {
+        task: TaskEntry;
+    };
+} | {
+    type: "DELETE_TASK";
+    entityType: "task";
+    entityId: string;
+    payload: {
+        id: string;
+    };
+};
+export interface TaskReduceResult {
+    state: TaskReducerState;
+    effects: TaskReducerEffect[];
+}
+export declare function reduceTaskState(state: TaskReducerState, event: TaskReducerEvent): TaskReduceResult;

package/dist/task-reducer.js

@@ -0,0 +1,76 @@
+function cloneState(state) {
+    return {
+        nextId: state.nextId,
+        tasksById: { ...state.tasksById },
+    };
+}
+export function reduceTaskState(state, event) {
+    if (event.type === "TASK_CREATED") {
+        const next = cloneState(state);
+        const id = String(next.nextId++);
+        const task = {
+            id,
+            subject: event.payload.subject,
+            description: event.payload.description,
+            status: "pending",
+            createdAt: event.at,
+            updatedAt: event.at,
+            metadata: event.payload.metadata,
+        };
+        next.tasksById[id] = task;
+        return {
+            state: next,
+            effects: [{ type: "PERSIST_TASK", entityType: "task", entityId: id, payload: { task } }],
+        };
+    }
+    if (event.type === "TASKS_PRUNED") {
+        const next = cloneState(state);
+        const effects = [];
+        for (const [id, task] of Object.entries(next.tasksById)) {
+            if (task.status !== "completed")
+                continue;
+            delete next.tasksById[id];
+            effects.push({ type: "DELETE_TASK", entityType: "task", entityId: id, payload: { id } });
+        }
+        return { state: next, effects };
+    }
+    const id = event.payload.id;
+    const current = state.tasksById[id];
+    if (!current)
+        return { state, effects: [] };
+    if (event.type === "TASK_DELETED") {
+        const next = cloneState(state);
+        delete next.tasksById[id];
+        return {
+            state: next,
+            effects: [{ type: "DELETE_TASK", entityType: "task", entityId: id, payload: { id } }],
+        };
+    }
+    const next = cloneState(state);
+    const task = { ...current };
+    if (event.type === "TASK_STARTED") {
+        task.status = "in_progress";
+        task.updatedAt = event.at;
+    }
+    if (event.type === "TASK_COMPLETED") {
+        task.status = "completed";
+        task.updatedAt = event.at;
+        task.completedAt = event.at;
+    }
+    if (event.type === "TASK_REOPENED") {
+        task.status = "pending";
+        task.updatedAt = event.at;
+    }
+    if (event.type === "TASK_UPDATED") {
+        if (event.payload.subject !== undefined)
+            task.subject = event.payload.subject;
+        if (event.payload.description !== undefined)
+            task.description = event.payload.description;
+        task.updatedAt = event.at;
+    }
+    next.tasksById[id] = task;
+    return {
+        state: next,
+        effects: [{ type: "PERSIST_TASK", entityType: "task", entityId: id, payload: { task } }],
+    };
+}

package/dist/task-store.d.ts

@@ -1,4 +1,4 @@
-import type { TaskEntry, TaskStatus } from "./task-types.js";
+import type { TaskEntry } from "./task-types.js";
 export declare class TaskStore {
     private filePath;
     private lockPath;
@@ -8,15 +8,19 @@ export declare class TaskStore {
     private load;
     private save;
     private withLock;
+    private toReducerState;
+    private applyReducerEvent;
     create(subject: string, description: string, metadata?: Record<string, unknown>): TaskEntry;
     get(id: string): TaskEntry | undefined;
     list(): TaskEntry[];
-    update(id: string, fields: {
-        status?: TaskStatus;
+    start(id: string): TaskEntry | undefined;
+    complete(id: string): TaskEntry | undefined;
+    reopen(id: string): TaskEntry | undefined;
+    updateDetails(id: string, fields: {
         subject?: string;
         description?: string;
     }): TaskEntry | undefined;
     delete(id: string): boolean;
     pendingCount(): number;
-    sweepCompleted(): number;
+    pruneCompleted(): number;
 }