@trevonistrevon/pi-loop 0.5.0 → 0.5.2

package/src/runtime/task-rpc.ts

@@ -0,0 +1,150 @@
+import { randomUUID } from "node:crypto";
+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 function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): TaskRuntimeBridge {
+  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: unknown) => {
+      unsub();
+      clearTimeout(timer);
+      const remoteVersion = (raw as { data?: { version?: number } })?.data?.version;
+      if (remoteVersion !== undefined) setTasksAvailable(true);
+    });
+    pi.events.emit("tasks:rpc:ping", { requestId });
+  }
+
+  async function autoCreateTask(entry: LoopEntry): Promise<string | undefined> {
+    if (!entry.autoTask) return undefined;
+    if (isTasksAvailable()) {
+      try {
+        const requestId = randomUUID();
+        const taskId = await new Promise<string | undefined>((resolve) => {
+          const timer = setTimeout(() => {
+            unsub();
+            resolve(undefined);
+          }, 5000);
+          const unsub = pi.events.on(`tasks:rpc:create:reply:${requestId}`, (raw: unknown) => {
+            unsub();
+            clearTimeout(timer);
+            const reply = raw as { success: boolean; data?: { id: string } };
+            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(): Promise<number> {
+    if (isTasksAvailable()) {
+      try {
+        const requestId = randomUUID();
+        const count = await new Promise<number>((resolve) => {
+          const timer = setTimeout(() => {
+            unsub();
+            resolve(-1);
+          }, 3000);
+          const unsub = pi.events.on(`tasks:rpc:pending:reply:${requestId}`, (raw: unknown) => {
+            unsub();
+            clearTimeout(timer);
+            const reply = raw as { success: boolean; data?: { pending: number } };
+            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(): Promise<void> {
+    if (isTasksAvailable()) {
+      try {
+        const requestId = randomUUID();
+        await new Promise<void>((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/src/store.ts

@@ -1,8 +1,8 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
 import { type LoopReducerEvent, type LoopReducerState, reduceLoopState } from "./loop-reducer.js";
-import type { LoopEntry, LoopStatus, LoopStoreData, Trigger } from "./types.js";
+import type { LoopEntry, LoopStoreData, Trigger } from "./types.js";
 
 const LOOPS_DIR = join(homedir(), ".pi", "loops");
 const LOCK_RETRY_MS = 50;
@@ -44,6 +44,7 @@ function isProcessRunning(pid: number): boolean {
 export class LoopStore {
   private filePath: string | undefined;
   private lockPath: string | undefined;
+  private lastLoadedSignature: string | undefined;
 
   private nextId = 1;
   private loops = new Map<string, LoopEntry>();
@@ -58,9 +59,17 @@ export class LoopStore {
     this.load();
   }
 
-  private load(): void {
+  private getFileSignature(): string | undefined {
+    if (!this.filePath || !existsSync(this.filePath)) return undefined;
+    const stat = statSync(this.filePath);
+    return `${stat.mtimeMs}:${stat.size}`;
+  }
+
+  private load(force = false): void {
     if (!this.filePath) return;
-    if (!existsSync(this.filePath)) return;
+    const signature = this.getFileSignature();
+    if (!signature) return;
+    if (!force && signature === this.lastLoadedSignature) return;
     try {
       const data: LoopStoreData = JSON.parse(readFileSync(this.filePath, "utf-8"));
       this.nextId = data.nextId;
@@ -68,6 +77,7 @@ export class LoopStore {
       for (const loop of data.loops) {
         this.loops.set(loop.id, loop);
       }
+      this.lastLoadedSignature = signature;
     } catch { /* corrupt file — start fresh */ }
   }
 
@@ -80,13 +90,14 @@ export class LoopStore {
     const tmpPath = this.filePath + ".tmp";
     writeFileSync(tmpPath, JSON.stringify(data, null, 2));
     renameSync(tmpPath, this.filePath);
+    this.lastLoadedSignature = this.getFileSignature();
   }
 
   private withLock<T>(fn: () => T): T {
     if (!this.lockPath) return fn();
     acquireLock(this.lockPath);
     try {
-      this.load();
+      this.load(true);
       const result = fn();
       this.save();
       return result;
@@ -143,38 +154,61 @@ export class LoopStore {
     return Array.from(this.loops.values()).sort((a, b) => Number(a.id) - Number(b.id));
   }
 
-  update(id: string, fields: { status?: LoopStatus; trigger?: Trigger; prompt?: string; fireCount?: number }): { entry: LoopEntry | undefined; changedFields: string[] } {
+  pause(id: string): LoopEntry | undefined {
     return this.withLock(() => {
       const entry = this.loops.get(id);
-      if (!entry) return { entry: undefined, changedFields: [] };
+      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);
+    });
+  }
 
-      const changedFields: string[] = [];
-      const now = Date.now();
+  resume(id: string): LoopEntry | undefined {
+    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);
+    });
+  }
 
-      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");
-      }
+  fire(id: string): LoopEntry | undefined {
+    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: string, fields: { trigger?: Trigger; prompt?: string }): { entry: LoopEntry | undefined; changedFields: string[] } {
+    return this.withLock(() => {
       const current = this.loops.get(id);
-      if (!current) return { entry: undefined, changedFields };
+      if (!current) return { entry: undefined, changedFields: [] };
+
+      const changedFields: string[] = [];
+      const now = Date.now();
 
       if (fields.trigger !== undefined) {
         current.trigger = fields.trigger;
@@ -184,24 +218,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;
       }
 

package/src/task-store.ts

@@ -1,8 +1,8 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
 import { reduceTaskState, type TaskReducerEvent, type TaskReducerState } from "./task-reducer.js";
-import type { TaskEntry, TaskStatus, TaskStoreData } from "./task-types.js";
+import type { TaskEntry, TaskStoreData } from "./task-types.js";
 
 const TASKS_DIR = join(homedir(), ".pi", "tasks");
 const LOCK_RETRY_MS = 50;
@@ -44,6 +44,7 @@ function isProcessRunning(pid: number): boolean {
 export class TaskStore {
   private filePath: string | undefined;
   private lockPath: string | undefined;
+  private lastLoadedSignature: string | undefined;
 
   private nextId = 1;
   private tasks = new Map<string, TaskEntry>();
@@ -58,9 +59,17 @@ export class TaskStore {
     this.load();
   }
 
-  private load(): void {
+  private getFileSignature(): string | undefined {
+    if (!this.filePath || !existsSync(this.filePath)) return undefined;
+    const stat = statSync(this.filePath);
+    return `${stat.mtimeMs}:${stat.size}`;
+  }
+
+  private load(force = false): void {
     if (!this.filePath) return;
-    if (!existsSync(this.filePath)) return;
+    const signature = this.getFileSignature();
+    if (!signature) return;
+    if (!force && signature === this.lastLoadedSignature) return;
     try {
       const data: TaskStoreData = JSON.parse(readFileSync(this.filePath, "utf-8"));
       this.nextId = data.nextId;
@@ -68,6 +77,7 @@ export class TaskStore {
       for (const task of data.tasks) {
         this.tasks.set(task.id, task);
       }
+      this.lastLoadedSignature = signature;
     } catch { /* corrupt file — start fresh */ }
   }
 
@@ -80,13 +90,14 @@ export class TaskStore {
     const tmpPath = this.filePath + ".tmp";
     writeFileSync(tmpPath, JSON.stringify(data, null, 2));
     renameSync(tmpPath, this.filePath);
+    this.lastLoadedSignature = this.getFileSignature();
   }
 
   private withLock<T>(fn: () => T): T {
     if (!this.lockPath) return fn();
     acquireLock(this.lockPath);
     try {
-      this.load();
+      this.load(true);
       const result = fn();
       this.save();
       return result;
@@ -135,56 +146,71 @@ export class TaskStore {
     return Array.from(this.tasks.values()).sort((a, b) => Number(a.id) - Number(b.id));
   }
 
-  update(id: string, fields: { status?: TaskStatus; subject?: string; description?: string }): TaskEntry | undefined {
+  start(id: string): TaskEntry | undefined {
     return this.withLock(() => {
       const entry = this.tasks.get(id);
       if (!entry) return undefined;
+      this.applyReducerEvent({
+        type: "TASK_STARTED",
+        at: Date.now(),
+        source: "tool",
+        entityType: "task",
+        entityId: id,
+        payload: { id },
+      });
+      return this.tasks.get(id);
+    });
+  }
 
-      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 },
-        });
-      }
+  complete(id: string): TaskEntry | undefined {
+    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);
+    });
+  }
 
-      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,
-          },
-        });
-      }
+  reopen(id: string): TaskEntry | undefined {
+    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: string, fields: { subject?: string; description?: string }): TaskEntry | undefined {
+    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);
     });
   }
@@ -212,7 +238,7 @@ export class TaskStore {
     return count;
   }
 
-  sweepCompleted(): number {
+  pruneCompleted(): number {
     return this.withLock(() => {
       const before = this.tasks.size;
       this.applyReducerEvent({