@trevonistrevon/pi-loop 0.3.0 → 0.4.0

package/src/index.ts

@@ -22,6 +22,7 @@ import { parseInterval } from "./loop-parse.js";
 import { MonitorManager } from "./monitor-manager.js";
 import { CronScheduler } from "./scheduler.js";
 import { LoopStore } from "./store.js";
+import { TaskStore } from "./task-store.js";
 import { TriggerSystem } from "./trigger-system.js";
 import type { LoopEntry, Trigger } from "./types.js";
 import { LoopWidget } from "./ui/widget.js";
@@ -68,19 +69,36 @@ export default function (pi: ExtensionAPI) {
     return join(process.cwd(), ".pi", "loops", "loops.json");
   }
 
+  function resolveTaskStorePath(): string | undefined {
+    if (loopScope === "memory") return undefined;
+    return join(process.cwd(), ".pi", "tasks", "tasks.json");
+  }
+
   let store = new LoopStore(resolveStorePath());
   const monitorManager = new MonitorManager(pi);
   let scheduler: CronScheduler;
   let triggerSystem: TriggerSystem;
-  const widget = new LoopWidget(store, undefined, monitorManager);
+  const widget = new LoopWidget(store, monitorManager);
+  widget.setTaskSummaryProvider(() => {
+    if (!nativeTaskStore) return { count: 0 };
+    const tasks = nativeTaskStore.list().filter(t => t.status === "pending" || t.status === "in_progress");
+    const active = tasks.find(t => t.status === "in_progress");
+    const next = tasks.find(t => t.status === "pending");
+    const focus = active
+      ? `active: ${active.subject.slice(0, 50)}`
+      : next
+        ? `next: ${next.subject.slice(0, 50)}`
+        : undefined;
+    return { count: tasks.length, focusText: focus };
+  });
 
   scheduler = new CronScheduler(store, onLoopFire);
-  widget.setScheduler(scheduler);
-  triggerSystem = new TriggerSystem(pi, scheduler, store);
+  triggerSystem = new TriggerSystem(pi, scheduler, store, onLoopFire);
 
   // ── pi-tasks integration ──
   let tasksAvailable = false;
-  const _PROTOCOL_VERSION = 1;
+  let nativeTaskStore: TaskStore | undefined;
+  let nativeTasksRegistered = false;
 
   function checkTasksVersion() {
     const requestId = randomUUID();
@@ -97,46 +115,79 @@ export default function (pi: ExtensionAPI) {
   pi.events.on("tasks:ready", () => checkTasksVersion());
 
   async function autoCreateTask(entry: LoopEntry): Promise<string | undefined> {
-    if (!tasksAvailable || !entry.autoTask) return undefined;
-    try {
-      const requestId = randomUUID();
-      const taskId = await new Promise<string | undefined>((resolve, _reject) => {
-        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 }; error?: string };
-          if (reply.success && reply.data) resolve(reply.data.id);
-          else resolve(undefined);
+    if (!entry.autoTask) return undefined;
+    if (tasksAvailable) {
+      try {
+        const requestId = randomUUID();
+        const taskId = await new Promise<string | undefined>((resolve, _reject) => {
+          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 }; error?: 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 },
+          });
         });
-        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;
+        return taskId;
+      } catch {
+        return undefined;
+      }
     }
+    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,
+    });
+    widget.update();
+    return task.id;
   }
 
   async function hasPendingTasks(): Promise<number> {
-    if (!tasksAvailable) return -1;
-    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 }; error?: string };
-          resolve(reply.success && reply.data ? reply.data.pending : -1);
+    if (tasksAvailable) {
+      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 }; error?: string };
+            resolve(reply.success && reply.data ? reply.data.pending : -1);
+          });
+          pi.events.emit("tasks:rpc:pending", { requestId });
         });
-        pi.events.emit("tasks:rpc:pending", { requestId });
-      });
-      return count;
-    } catch {
-      return -1;
+        return count;
+      } catch {
+        return -1;
+      }
+    }
+    return nativeTaskStore ? nativeTaskStore.pendingCount() : -1;
+  }
+
+  async function cleanDoneTasks(): Promise<void> {
+    if (tasksAvailable) {
+      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;
+    }
+    if (nativeTaskStore) {
+      nativeTaskStore.sweepCompleted();
+      widget.update();
     }
   }
 
@@ -147,7 +198,7 @@ export default function (pi: ExtensionAPI) {
 
     if (entry.maxFires && (entry.fireCount ?? 0) >= entry.maxFires) {
       debug(`loop #${entry.id} — reached maxFires ${entry.maxFires}, expiring`);
-      store.update(entry.id, { status: "expired" });
+      store.delete(entry.id);
       return;
     }
     store.update(entry.id, { fireCount: (entry.fireCount ?? 0) + 1 });
@@ -183,8 +234,7 @@ export default function (pi: ExtensionAPI) {
       store = new LoopStore(path);
       widget.setStore(store);
       scheduler = new CronScheduler(store, onLoopFire);
-      widget.setScheduler(scheduler);
-      triggerSystem = new TriggerSystem(pi, scheduler, store);
+      triggerSystem = new TriggerSystem(pi, scheduler, store, onLoopFire);
     }
     storeUpgraded = true;
   }
@@ -206,6 +256,7 @@ export default function (pi: ExtensionAPI) {
     _latestCtx = ctx;
     widget.setUICtx(ctx.ui);
     upgradeStoreIfNeeded(ctx);
+    widget.update();
   });
 
   pi.on("before_agent_start", async (_event, ctx) => {
@@ -213,6 +264,7 @@ export default function (pi: ExtensionAPI) {
     widget.setUICtx(ctx.ui);
     upgradeStoreIfNeeded(ctx);
     showPersistedLoops();
+    widget.update();
   });
 
   pi.on("session_switch" as any, async (event: SessionSwitchEvent, ctx: ExtensionContext) => {
@@ -230,6 +282,7 @@ export default function (pi: ExtensionAPI) {
 
     upgradeStoreIfNeeded(ctx);
     showPersistedLoops(isResume);
+    widget.update();
   });
 
   // ── Loop fire handler — sends a user message to re-wake the agent ──
@@ -245,7 +298,8 @@ export default function (pi: ExtensionAPI) {
     if (data.autoTask) {
       const pending = await hasPendingTasks();
       if (pending === 0) {
-        debug(`loop:fire #${data.loopId} — no pending tasks, skipping`);
+        debug(`loop:fire #${data.loopId} — no pending tasks, skipping, requesting cleanup`);
+        cleanDoneTasks();
         return;
       }
     }
@@ -382,7 +436,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
             if (monitor && monitor.status !== "running") {
               debug(`loop #${entry.id} — monitor #${monitorId} already ${monitor.status}, expiring`);
               triggerSystem.remove(entry.id);
-              store.update(entry.id, { status: "expired" });
+              store.delete(entry.id);
             }
           }
         } catch { /* filter parse failure, ignore */ }
@@ -413,7 +467,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
     if (monitor && monitor.status !== "running") {
       debug(`onDone loop #${doneLoop.id} — monitor #${monitorId} already ${monitor.status}, expiring`);
       triggerSystem.remove(doneLoop.id);
-      store.update(doneLoop.id, { status: "expired" });
+      store.delete(doneLoop.id);
     }
   }
 
@@ -474,7 +528,7 @@ Use this before creating new loops to avoid duplicates, or to find IDs for LoopD
           ? scheduler.nextFire(entry.id)
           : undefined;
 
-        const statusIcon = entry.status === "active" ? "⟳" : entry.status === "paused" ? "⏸" : "✗";
+        const statusIcon = entry.status === "active" ? "*" : entry.status === "paused" ? "-" : "x";
         let line = `${statusIcon} #${entry.id} [${entry.status}] ${entry.prompt.slice(0, 60)}`;
         line += ` (${triggerDesc})`;
         if (nextFire) {
@@ -607,7 +661,7 @@ Pass onDone with a prompt and the monitor auto-creates a one-shot loop that fire
 
       const lines: string[] = [];
       for (const m of monitors) {
-        const icon = m.status === "running" ? "◉" : m.status === "completed" ? "✓" : "✗";
+        const icon = m.status === "running" ? ">" : m.status === "completed" ? "ok" : "!!";
         const age = Date.now() - m.startedAt;
         const ageStr = formatRemaining(age);
         let line = `${icon} #${m.id} [${m.status}] ${m.command.slice(0, 60)} — ${m.outputLines} lines (${ageStr})`;
@@ -744,45 +798,45 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
   async function viewLoops(ui: ExtensionUIContext) {
     const loops = store.list();
     if (loops.length === 0) {
-      await ui.select("No active loops", ["← Back"]);
+      await ui.select("No active loops", ["< Back"]);
       return;
     }
 
     const choices = loops.map((l: LoopEntry) => {
-      const icon = l.status === "active" ? "⟳" : l.status === "paused" ? "⏸" : "✗";
+      const icon = l.status === "active" ? "*" : l.status === "paused" ? "-" : "x";
       const triggerDesc = l.trigger.type === "cron" ? `cron: ${l.trigger.schedule}` : l.trigger.type === "event" ? `event: ${l.trigger.source}` : `hybrid: ${l.trigger.cron}`;
       return `${icon} #${l.id} [${l.status}] ${l.prompt.slice(0, 50)} (${triggerDesc})`;
     });
-    choices.push("← Back");
+    choices.push("< Back");
 
     const selected = await ui.select("Active Loops", choices);
-    if (!selected || selected === "← Back") return;
+    if (!selected || selected === "< Back") return;
 
     const match = selected.match(/#(\d+)/);
     if (match) {
       const entry = store.get(match[1]);
       if (entry) {
-        const actions = ["✗ Delete"];
-        if (entry.status === "active") actions.unshift("⏸ Pause");
-        else if (entry.status === "paused") actions.unshift("▶ Resume");
-        actions.push("← Back");
+        const actions = ["x Delete"];
+        if (entry.status === "active") actions.unshift("- Pause");
+        else if (entry.status === "paused") actions.unshift("* Resume");
+        actions.push("< Back");
 
         const action = await ui.select(
           `#${entry.id}: ${entry.prompt}\nTrigger: ${JSON.stringify(entry.trigger)}`,
           actions,
         );
 
-        if (action === "✗ Delete") {
+        if (action === "x Delete") {
           triggerSystem.remove(entry.id);
           store.delete(entry.id);
           widget.update();
           ui.notify(`Loop #${entry.id} deleted`, "info");
-        } else if (action === "⏸ Pause") {
+        } else if (action === "- Pause") {
           store.update(entry.id, { status: "paused" });
           triggerSystem.remove(entry.id);
           widget.update();
           ui.notify(`Loop #${entry.id} paused`, "info");
-        } else if (action === "▶ Resume") {
+        } else if (action === "* Resume") {
           store.update(entry.id, { status: "active" });
           triggerSystem.add(entry);
           widget.update();
@@ -799,4 +853,193 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
     const active = loops.filter(l => l.status === "active").length;
     ui.notify(`${active}/${loops.length} active loops (max 25)`, "info");
   }
+
+  async function createNativeTaskInteractively(ui: ExtensionUIContext) {
+    if (!nativeTaskStore) {
+      ui.notify("Native tasks are unavailable while pi-tasks is active", "warning");
+      return;
+    }
+
+    const subject = await ui.input("Task subject");
+    if (!subject) return;
+    const description = await ui.input("Task description") || subject;
+    const entry = nativeTaskStore.create(subject, description);
+    widget.update();
+    ui.notify(`Task #${entry.id} created`, "info");
+  }
+
+  async function viewNativeTasks(ui: ExtensionUIContext): Promise<void> {
+    if (!nativeTaskStore) {
+      ui.notify("Native tasks are unavailable while pi-tasks is active", "warning");
+      return;
+    }
+
+    const tasks = nativeTaskStore.list();
+    const choices = tasks.map((task) => {
+      const icon = task.status === "in_progress" ? ">" : task.status === "completed" ? "ok" : "*";
+      return `${icon} #${task.id} [${task.status}] ${task.subject.slice(0, 60)}`;
+    });
+    choices.unshift("+ Create task");
+    choices.push("< Back");
+
+    const selected = await ui.select("Native Tasks", choices);
+    if (!selected || selected === "< Back") return;
+    if (selected === "+ Create task") {
+      await createNativeTaskInteractively(ui);
+      return viewNativeTasks(ui);
+    }
+
+    const match = selected.match(/#(\d+)/);
+    if (!match) return viewNativeTasks(ui);
+
+    const task = nativeTaskStore.get(match[1]);
+    if (!task) return viewNativeTasks(ui);
+
+    const actions = ["x Delete"];
+    if (task.status === "pending") {
+      actions.unshift("ok Complete");
+      actions.unshift("> Start");
+    } else if (task.status === "in_progress") {
+      actions.unshift("ok Complete");
+      actions.unshift("* Return to pending");
+    } else {
+      actions.unshift("* Reopen");
+    }
+    actions.push("< Back");
+
+    const action = await ui.select(`#${task.id}: ${task.subject}\n\n${task.description}`, actions);
+    if (!action || action === "< Back") return viewNativeTasks(ui);
+
+    if (action === "x Delete") {
+      nativeTaskStore.delete(task.id);
+      ui.notify(`Task #${task.id} deleted`, "info");
+    } else if (action === "> Start") {
+      nativeTaskStore.update(task.id, { status: "in_progress" });
+      ui.notify(`Task #${task.id} started`, "info");
+    } else if (action === "ok Complete") {
+      nativeTaskStore.update(task.id, { status: "completed" });
+      ui.notify(`Task #${task.id} completed`, "info");
+    } else if (action === "* Return to pending" || action === "* Reopen") {
+      nativeTaskStore.update(task.id, { status: "pending" });
+      ui.notify(`Task #${task.id} reopened`, "info");
+    }
+
+    widget.update();
+    return viewNativeTasks(ui);
+  }
+
+  // ── Native task tools (only when pi-tasks is absent) ──
+
+  setTimeout(async () => {
+    if (tasksAvailable || nativeTasksRegistered) return;
+    nativeTaskStore = new TaskStore(resolveTaskStorePath());
+    nativeTasksRegistered = true;
+    const taskStore = nativeTaskStore;
+
+    pi.registerCommand("tasks", {
+      description: "View or manage native pi-loop tasks when pi-tasks is not installed",
+      handler: async (args: string, ctx: ExtensionCommandContext) => {
+        const trimmed = args.trim();
+        if (!nativeTaskStore) {
+          ctx.ui.notify("Native tasks are unavailable while pi-tasks is active", "warning");
+          return;
+        }
+        if (trimmed) {
+          const entry = nativeTaskStore.create(trimmed.slice(0, 80), trimmed);
+          widget.update();
+          ctx.ui.notify(`Task #${entry.id} created`, "info");
+          return;
+        }
+        await viewNativeTasks(ctx.ui);
+      },
+    });
+
+    pi.registerTool({
+      name: "TaskCreate",
+      label: "TaskCreate",
+      description: `Create a task for tracking work across turns. Use when you need to track progress on complex multi-step tasks.
+
+Fields:
+- subject: brief actionable title
+- description: detailed requirements
+- metadata: optional tags/metadata`,
+      parameters: Type.Object({
+        subject: Type.String({ description: "Brief actionable title for the task" }),
+        description: Type.String({ description: "Detailed description of what needs to be done" }),
+      }),
+      execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+        const entry = taskStore.create(params.subject, params.description);
+        widget.update();
+        return Promise.resolve(textResult(`Task #${entry.id} created: ${entry.subject}`));
+      },
+    });
+
+    pi.registerTool({
+      name: "TaskList",
+      label: "TaskList",
+      description: `List all tasks with status. Use to check progress and find available work.`,
+      parameters: Type.Object({}),
+      execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
+        const tasks = taskStore.list();
+        if (tasks.length === 0) return Promise.resolve(textResult("No tasks."));
+
+        const lines: string[] = [];
+        const statuses: Record<"pending" | "in_progress" | "completed", number> = {
+          pending: 0,
+          in_progress: 0,
+          completed: 0,
+        };
+        for (const t of tasks) {
+          statuses[t.status]++;
+          const icon = t.status === "completed" ? "ok" : t.status === "in_progress" ? ">" : "*";
+          lines.push(`${icon} #${t.id} [${t.status}] ${t.subject.slice(0, 80)}`);
+        }
+        lines.unshift(`${tasks.length} tasks (${statuses.pending} pending, ${statuses.in_progress} in progress, ${statuses.completed} done)`);
+        return Promise.resolve(textResult(lines.join("\n")));
+      },
+    });
+
+    pi.registerTool({
+      name: "TaskUpdate",
+      label: "TaskUpdate",
+      description: `Update task status or details. Set status to "in_progress" before starting work, "completed" when done.
+
+Statuses: pending → in_progress → completed`,
+      parameters: Type.Object({
+        id: Type.String({ description: "Task ID to update" }),
+        status: Type.Optional(Type.String({ description: "New status", enum: ["pending", "in_progress", "completed"] })),
+        subject: Type.Optional(Type.String({ description: "New title" })),
+        description: Type.Optional(Type.String({ description: "New description" })),
+      }),
+      execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+        const { id, status, subject, description } = params;
+        const entry = taskStore.update(id, {
+          status: status as "pending" | "in_progress" | "completed" | undefined,
+          subject,
+          description,
+        });
+        if (!entry) return Promise.resolve(textResult(`Task #${id} not found`));
+        widget.update();
+        const statusMsg = status ? ` → ${status}` : "";
+        return Promise.resolve(textResult(`Task #${id} updated${statusMsg}`));
+      },
+    });
+
+    pi.registerTool({
+      name: "TaskDelete",
+      label: "TaskDelete",
+      description: `Delete a task by ID. Use for cleaning up completed or irrelevant tasks.`,
+      parameters: Type.Object({
+        id: Type.String({ description: "Task ID to delete" }),
+      }),
+      execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+        const deleted = taskStore.delete(params.id);
+        widget.update();
+        if (deleted) return Promise.resolve(textResult(`Task #${params.id} deleted`));
+        return Promise.resolve(textResult(`Task #${params.id} not found`));
+      },
+    });
+
+    debug("native task tools registered (pi-tasks not detected)");
+  }, 6000);
 }

package/src/scheduler.ts

@@ -65,7 +65,7 @@ export class CronScheduler {
     const now = Date.now();
 
     if (fireTime > entry.expiresAt) {
-      this.store.update(entry.id, { status: "expired" });
+      this.store.delete(entry.id);
       return;
     }
 
@@ -85,7 +85,7 @@ export class CronScheduler {
 
       const now2 = Date.now();
       if (now2 >= current.expiresAt) {
-        this.store.update(entry.id, { status: "expired" });
+        this.store.delete(entry.id);
         this.timers.delete(entry.id);
         this.fireTimes.delete(entry.id);
         return;
@@ -96,7 +96,7 @@ export class CronScheduler {
       if (current.recurring) {
         const fresh = this.store.get(entry.id);
         if (fresh?.maxFires && (fresh.fireCount ?? 0) >= fresh.maxFires) {
-          this.store.update(entry.id, { status: "expired" });
+          this.store.delete(entry.id);
           this.timers.delete(entry.id);
           this.fireTimes.delete(entry.id);
           return;