@trevonistrevon/pi-loop 0.5.0 → 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;
@@ -19,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

@@ -149,38 +149,61 @@ 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 = [];
             const now = Date.now();
-            if (fields.status === "paused") {
-                this.applyReducerEvent({
-                    type: "LOOP_PAUSED",
-                    at: now,
-                    source: "tool",
-                    entityType: "loop",
-                    entityId: id,
-                    payload: { id },
-                });
-                changedFields.push("status");
-            }
-            else if (fields.status === "active") {
-                this.applyReducerEvent({
-                    type: "LOOP_RESUMED",
-                    at: now,
-                    source: "tool",
-                    entityType: "loop",
-                    entityId: id,
-                    payload: { id },
-                });
-                changedFields.push("status");
-            }
-            const current = this.loops.get(id);
-            if (!current)
-                return { entry: undefined, changedFields };
             if (fields.trigger !== undefined) {
                 current.trigger = fields.trigger;
                 changedFields.push("trigger");
@@ -189,24 +212,7 @@ export class LoopStore {
                 current.prompt = fields.prompt;
                 changedFields.push("prompt");
             }
-            if (fields.fireCount !== undefined) {
-                if (fields.fireCount === (current.fireCount ?? 0) + 1) {
-                    this.applyReducerEvent({
-                        type: "LOOP_FIRED",
-                        at: now,
-                        source: "system",
-                        entityType: "loop",
-                        entityId: id,
-                        payload: { id },
-                    });
-                }
-                else {
-                    current.fireCount = fields.fireCount;
-                    current.updatedAt = now;
-                }
-                changedFields.push("fireCount");
-            }
-            if (fields.trigger !== undefined || fields.prompt !== undefined) {
+            if (changedFields.length > 0) {
                 current.updatedAt = now;
             }
             return { entry: this.loops.get(id), changedFields };

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;
@@ -13,12 +13,14 @@ export declare class TaskStore {
     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;
 }

package/dist/task-store.js

@@ -141,56 +141,73 @@ export class TaskStore {
             this.load();
         return Array.from(this.tasks.values()).sort((a, b) => Number(a.id) - Number(b.id));
     }
-    update(id, fields) {
+    start(id) {
         return this.withLock(() => {
             const entry = this.tasks.get(id);
             if (!entry)
                 return undefined;
-            const now = Date.now();
-            if (fields.status === "in_progress") {
-                this.applyReducerEvent({
-                    type: "TASK_STARTED",
-                    at: now,
-                    source: "tool",
-                    entityType: "task",
-                    entityId: id,
-                    payload: { id },
-                });
-            }
-            else if (fields.status === "completed") {
-                this.applyReducerEvent({
-                    type: "TASK_COMPLETED",
-                    at: now,
-                    source: "tool",
-                    entityType: "task",
-                    entityId: id,
-                    payload: { id },
-                });
-            }
-            else if (fields.status === "pending") {
-                this.applyReducerEvent({
-                    type: "TASK_REOPENED",
-                    at: now,
-                    source: "tool",
-                    entityType: "task",
-                    entityId: id,
-                    payload: { id },
-                });
-            }
-            if (fields.subject !== undefined || fields.description !== undefined) {
-                this.applyReducerEvent({
-                    type: "TASK_UPDATED",
-                    at: now,
-                    source: "tool",
-                    entityType: "task",
-                    entityId: id,
-                    payload: {
-                        id,
-                        subject: fields.subject,
-                        description: fields.description,
-                    },
-                });
-            }
+            this.applyReducerEvent({
+                type: "TASK_STARTED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "task",
+                entityId: id,
+                payload: { id },
+            });
+            return this.tasks.get(id);
+        });
+    }
+    complete(id) {
+        return this.withLock(() => {
+            const entry = this.tasks.get(id);
+            if (!entry)
+                return undefined;
+            this.applyReducerEvent({
+                type: "TASK_COMPLETED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "task",
+                entityId: id,
+                payload: { id },
+            });
+            return this.tasks.get(id);
+        });
+    }
+    reopen(id) {
+        return this.withLock(() => {
+            const entry = this.tasks.get(id);
+            if (!entry)
+                return undefined;
+            this.applyReducerEvent({
+                type: "TASK_REOPENED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "task",
+                entityId: id,
+                payload: { id },
+            });
+            return this.tasks.get(id);
+        });
+    }
+    updateDetails(id, fields) {
+        return this.withLock(() => {
+            const entry = this.tasks.get(id);
+            if (!entry)
+                return undefined;
+            if (fields.subject === undefined && fields.description === undefined)
+                return entry;
+            this.applyReducerEvent({
+                type: "TASK_UPDATED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "task",
+                entityId: id,
+                payload: {
+                    id,
+                    subject: fields.subject,
+                    description: fields.description,
+                },
+            });
             return this.tasks.get(id);
         });
     }
@@ -217,7 +234,7 @@ export class TaskStore {
         }
         return count;
     }
-    sweepCompleted() {
+    pruneCompleted() {
         return this.withLock(() => {
             const before = this.tasks.size;
             this.applyReducerEvent({

package/dist/tools/loop-tools.d.ts

@@ -0,0 +1,41 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { LoopEntry, Trigger } from "../types.js";
+interface LoopStoreLike {
+    list(): LoopEntry[];
+    get(id: string): LoopEntry | undefined;
+    create(trigger: Trigger, prompt: string, opts: {
+        recurring: boolean;
+        autoTask?: boolean;
+        taskBacklog?: boolean;
+        readOnly?: boolean;
+        maxFires?: number;
+    }): LoopEntry;
+    pause(id: string): LoopEntry | undefined;
+    delete(id: string): boolean;
+}
+interface TriggerSystemLike {
+    add(entry: LoopEntry): void;
+    remove(id: string): void;
+}
+interface SchedulerLike {
+    nextFire(id: string): number | undefined;
+}
+interface MonitorLike {
+    id: string;
+    status: string;
+}
+interface MonitorManagerLike {
+    get(id: string): MonitorLike | undefined;
+}
+export interface LoopToolsOptions {
+    pi: ExtensionAPI;
+    getStore: () => LoopStoreLike;
+    getTriggerSystem: () => TriggerSystemLike;
+    getScheduler: () => SchedulerLike;
+    getMonitorManager: () => MonitorManagerLike;
+    updateWidget: () => void;
+    maybeBootstrapTaskLoop: (entry: LoopEntry) => Promise<boolean>;
+    isTaskSystemReady: () => boolean;
+}
+export declare function registerLoopTools(options: LoopToolsOptions): void;
+export {};