@trevonistrevon/pi-loop 0.3.1 → 0.4.1

package/src/task-store.ts

@@ -0,0 +1,171 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import type { TaskEntry, TaskStatus, TaskStoreData } from "./task-types.js";
+
+const TASKS_DIR = join(homedir(), ".pi", "tasks");
+const LOCK_RETRY_MS = 50;
+const LOCK_MAX_RETRIES = 100;
+const MAX_TASKS = 200;
+
+function acquireLock(lockPath: string): void {
+  for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
+    try {
+      writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
+      return;
+    } catch (e: any) {
+      if (e.code === "EEXIST") {
+        try {
+          const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
+          if (!pid || !isProcessRunning(pid)) {
+            try { unlinkSync(lockPath); } catch { /* ignore */ }
+            continue;
+          }
+        } catch { /* ignore read errors */ }
+        const start = Date.now();
+        while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
+        continue;
+      }
+      throw e;
+    }
+  }
+  throw new Error(`Failed to acquire lock: ${lockPath}`);
+}
+
+function releaseLock(lockPath: string): void {
+  try { unlinkSync(lockPath); } catch { /* ignore */ }
+}
+
+function isProcessRunning(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+export class TaskStore {
+  private filePath: string | undefined;
+  private lockPath: string | undefined;
+
+  private nextId = 1;
+  private tasks = new Map<string, TaskEntry>();
+
+  constructor(listIdOrPath?: string) {
+    if (!listIdOrPath) return;
+    const isAbsPath = isAbsolute(listIdOrPath);
+    const filePath = isAbsPath ? listIdOrPath : join(TASKS_DIR, `${listIdOrPath}.json`);
+    mkdirSync(dirname(filePath), { recursive: true });
+    this.filePath = filePath;
+    this.lockPath = filePath + ".lock";
+    this.load();
+  }
+
+  private load(): void {
+    if (!this.filePath) return;
+    if (!existsSync(this.filePath)) return;
+    try {
+      const data: TaskStoreData = JSON.parse(readFileSync(this.filePath, "utf-8"));
+      this.nextId = data.nextId;
+      this.tasks.clear();
+      for (const task of data.tasks) {
+        this.tasks.set(task.id, task);
+      }
+    } catch { /* corrupt file — start fresh */ }
+  }
+
+  private save(): void {
+    if (!this.filePath) return;
+    const data: TaskStoreData = {
+      nextId: this.nextId,
+      tasks: Array.from(this.tasks.values()),
+    };
+    const tmpPath = this.filePath + ".tmp";
+    writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+    renameSync(tmpPath, this.filePath);
+  }
+
+  private withLock<T>(fn: () => T): T {
+    if (!this.lockPath) return fn();
+    acquireLock(this.lockPath);
+    try {
+      this.load();
+      const result = fn();
+      this.save();
+      return result;
+    } finally {
+      releaseLock(this.lockPath);
+    }
+  }
+
+  create(subject: string, description: string, metadata?: Record<string, unknown>): TaskEntry {
+    return this.withLock(() => {
+      if (this.tasks.size >= MAX_TASKS) {
+        throw new Error(`Maximum of ${MAX_TASKS} tasks reached. Delete some before creating new ones.`);
+      }
+      const now = Date.now();
+      const entry: TaskEntry = {
+        id: String(this.nextId++),
+        subject,
+        description,
+        status: "pending",
+        createdAt: now,
+        updatedAt: now,
+        metadata,
+      };
+      this.tasks.set(entry.id, entry);
+      return entry;
+    });
+  }
+
+  get(id: string): TaskEntry | undefined {
+    if (this.filePath) this.load();
+    return this.tasks.get(id);
+  }
+
+  list(): TaskEntry[] {
+    if (this.filePath) this.load();
+    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 {
+    return this.withLock(() => {
+      const entry = this.tasks.get(id);
+      if (!entry) return undefined;
+
+      if (fields.status !== undefined) {
+        entry.status = fields.status;
+        if (fields.status === "completed") entry.completedAt = Date.now();
+      }
+      if (fields.subject !== undefined) entry.subject = fields.subject;
+      if (fields.description !== undefined) entry.description = fields.description;
+      entry.updatedAt = Date.now();
+      return entry;
+    });
+  }
+
+  delete(id: string): boolean {
+    return this.withLock(() => {
+      if (!this.tasks.has(id)) return false;
+      this.tasks.delete(id);
+      return true;
+    });
+  }
+
+  pendingCount(): number {
+    let count = 0;
+    for (const t of this.tasks.values()) {
+      if (t.status === "pending" || t.status === "in_progress") count++;
+    }
+    return count;
+  }
+
+  sweepCompleted(): number {
+    return this.withLock(() => {
+      let count = 0;
+      for (const [id, entry] of this.tasks) {
+        if (entry.status === "completed") {
+          this.tasks.delete(id);
+          count++;
+        }
+      }
+      return count;
+    });
+  }
+}

package/src/task-types.ts

@@ -0,0 +1,17 @@
+export type TaskStatus = "pending" | "in_progress" | "completed";
+
+export interface TaskEntry {
+  id: string;
+  subject: string;
+  description: string;
+  status: TaskStatus;
+  createdAt: number;
+  updatedAt: number;
+  completedAt?: number;
+  metadata?: Record<string, unknown>;
+}
+
+export interface TaskStoreData {
+  nextId: number;
+  tasks: TaskEntry[];
+}

package/src/trigger-system.ts

@@ -12,6 +12,7 @@ export class TriggerSystem {
     private pi: ExtensionAPI,
     private scheduler: CronScheduler,
     private store: LoopStore,
+    private onFire: (entry: LoopEntry) => void,
   ) {}
 
   start(): void {
@@ -94,27 +95,30 @@ export class TriggerSystem {
   }
 
   private fireLoop(entry: LoopEntry): void {
-    if (entry.maxFires && (entry.fireCount ?? 0) >= entry.maxFires) {
-      this.store.delete(entry.id);
+    const current = this.store.get(entry.id);
+    if (!current || current.status !== "active") {
       this.remove(entry.id);
       return;
     }
-    this.store.update(entry.id, { fireCount: (entry.fireCount ?? 0) + 1 });
-
-    this.lastFireTime.set(entry.id, Date.now());
-    this.pi.events.emit("loop:fire", {
-      loopId: entry.id,
-      prompt: entry.prompt,
-      trigger: entry.trigger,
-      timestamp: Date.now(),
-      readOnly: entry.readOnly,
-      recurring: entry.recurring,
-      autoTask: entry.autoTask,
-    });
 
-    if (!entry.recurring) {
+    this.lastFireTime.set(current.id, Date.now());
+    this.onFire(current);
+
+    const fresh = this.store.get(entry.id);
+    if (!fresh) {
       this.remove(entry.id);
-      this.store.delete(entry.id);
+      return;
+    }
+
+    if (fresh.recurring && fresh.maxFires && (fresh.fireCount ?? 0) >= fresh.maxFires) {
+      this.remove(fresh.id);
+      this.store.delete(fresh.id);
+      return;
+    }
+
+    if (!fresh.recurring) {
+      this.remove(fresh.id);
+      this.store.delete(fresh.id);
     }
   }
 

package/src/ui/widget.ts

@@ -1,21 +1,19 @@
-import type { ExtensionUIContext, Theme } from "@earendil-works/pi-coding-agent";
-import type { Component, TUI } from "@earendil-works/pi-tui";
-import { truncateToWidth } from "@earendil-works/pi-tui";
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import type { MonitorManager } from "../monitor-manager.js";
-import type { CronScheduler } from "../scheduler.js";
 import type { LoopStore } from "../store.js";
 
-const MAX_VISIBLE = 6;
+interface TaskSummary {
+  count: number;
+  focusText?: string;
+}
 
 export class LoopWidget {
   private uiCtx: ExtensionUIContext | undefined;
-  private tui: TUI | undefined;
-  private widgetRegistered = false;
   private interval: ReturnType<typeof setInterval> | undefined;
+  private taskSummaryProvider: (() => TaskSummary) | undefined;
 
   constructor(
     private store: LoopStore,
-    private scheduler: CronScheduler | undefined,
     private monitorManager: MonitorManager,
   ) {}
 
@@ -27,108 +25,53 @@ export class LoopWidget {
     this.store = store;
   }
 
-  setScheduler(scheduler: CronScheduler) {
-    this.scheduler = scheduler;
+  setTaskSummaryProvider(provider: (() => TaskSummary) | undefined) {
+    this.taskSummaryProvider = provider;
   }
 
   update() {
     if (!this.uiCtx) return;
 
-    const loops = this.store.list().filter(l => l.status === "active");
-    const monitors = this.monitorManager.list();
-    const hasContent = loops.length > 0 || monitors.length > 0;
-
-    if (!hasContent) {
-      if (this.widgetRegistered) {
-        this.uiCtx.setWidget("loops", undefined);
-        this.widgetRegistered = false;
-      }
-      if (this.interval) {
-        clearInterval(this.interval);
-        this.interval = undefined;
-      }
-      return;
-    }
-
-    if (!this.interval) {
+    const status = this.computeStatus();
+    if (status && !this.interval) {
       this.interval = setInterval(() => this.update(), 5000);
     }
-
-    if (!this.widgetRegistered) {
-      this.uiCtx.setWidget("loops", (tui: TUI, theme: Theme) => {
-        this.tui = tui;
-        return { render: () => this.renderWidget(tui, theme), invalidate: () => {} } as Component & { dispose?(): void };
-      }, { placement: "aboveEditor" });
-      this.widgetRegistered = true;
-    } else if (this.tui) {
-      (this.tui as any).requestRender();
+    if (!status && this.interval) {
+      clearInterval(this.interval);
+      this.interval = undefined;
     }
+
+    this.uiCtx.setStatus("loops", status);
   }
 
-  private renderWidget(tui: TUI, _theme: Theme): string[] {
+  private computeStatus(): string | undefined {
     const loops = this.store.list().filter(l => l.status === "active");
-    const runningMonitors = this.monitorManager.list().filter(m => m.status === "running");
-    const completedMonitors = this.monitorManager.list().filter(m => m.status === "completed");
-    const allMonitors = [...runningMonitors, ...completedMonitors];
-    const w = tui.terminal.columns;
-    const trunc = (line: string) => truncateToWidth(line, w);
-
-    const lines: string[] = [];
-    const total = loops.length + allMonitors.length;
-
-    if (total === 0) return [];
-
-    const headerParts: string[] = [`⟳ ${loops.length} loops`];
-    if (runningMonitors.length > 0) headerParts.push(`${runningMonitors.length} running`);
-    if (completedMonitors.length > 0) headerParts.push(`${completedMonitors.length} done`);
-    lines.push(trunc(headerParts.join(" · ")));
+    const monitors = this.monitorManager.list();
+    const taskSummary = this.taskSummaryProvider?.() ?? { count: 0 };
 
-    for (const loop of loops.slice(0, MAX_VISIBLE)) {
-      const icon = "◷";
-      let schedule = "";
-      if (loop.trigger.type === "cron") {
-        schedule = loop.trigger.schedule;
-      } else if (loop.trigger.type === "event") {
-        schedule = `event: ${loop.trigger.source}`;
-      } else if (loop.trigger.type === "hybrid") {
-        schedule = `hybrid: ${loop.trigger.cron}`;
-      }
-      const nextFire = this.scheduler?.nextFire(loop.id);
-      let timing = "";
-      if (nextFire) {
-        const remaining = Math.max(0, nextFire - Date.now());
-        timing = ` (next: ${formatDuration(remaining)})`;
-      }
-      lines.push(trunc(`  ${icon} #${loop.id} ${loop.prompt.slice(0, 50)} → ${schedule}${timing}`));
+    if (loops.length === 0 && monitors.length === 0 && taskSummary.count === 0) {
+      return undefined;
     }
 
-    for (const m of allMonitors.slice(0, Math.max(0, MAX_VISIBLE - loops.length))) {
-      const icon = m.status === "running" ? "◉" : "✓";
-      const age = Date.now() - m.startedAt;
-      const label = m.description || m.command.replace(/\n/g, " ").replace(/\s+/g, " ").trim().slice(0, 50);
-      let line = `  ${icon} #${m.id} ${label} ${m.outputLines} lines (${formatDuration(age)})`;
-      if (m.exitCode !== undefined && m.status !== "running") line += ` exit=${m.exitCode}`;
-      lines.push(trunc(line));
-    }
+    const parts: string[] = [];
+    if (loops.length > 0) parts.push(formatCount(loops.length, "loop"));
+    if (monitors.length > 0) parts.push(formatCount(monitors.length, "monitor"));
+    if (taskSummary.count > 0) parts.push(formatCount(taskSummary.count, "task"));
 
-    return lines;
+    let line = parts.join(" · ");
+    if (taskSummary.focusText) line += ` | ${taskSummary.focusText}`;
+    return line;
   }
 
   dispose() {
-    if (this.interval) { clearInterval(this.interval); this.interval = undefined; }
-    if (this.uiCtx) this.uiCtx.setWidget("loops", undefined);
-    this.widgetRegistered = false;
-    this.tui = undefined;
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = undefined;
+    }
+    this.uiCtx?.setStatus("loops", undefined);
   }
 }
 
-function formatDuration(ms: number): string {
-  const totalSec = Math.floor(ms / 1000);
-  if (totalSec < 60) return `${totalSec}s`;
-  const min = Math.floor(totalSec / 60);
-  const sec = totalSec % 60;
-  if (min < 60) return sec > 0 ? `${min}m ${sec}s` : `${min}m`;
-  const hr = Math.floor(min / 60);
-  const remMin = min % 60;
-  return remMin > 0 ? `${hr}h ${remMin}m` : `${hr}h`;
+function formatCount(count: number, noun: string): string {
+  return `${count} ${noun}${count === 1 ? "" : "s"}`;
 }