@trevonistrevon/pi-loop 0.3.1 → 0.4.1

package/dist/task-store.d.ts

@@ -0,0 +1,22 @@
+import type { TaskEntry, TaskStatus } from "./task-types.js";
+export declare class TaskStore {
+    private filePath;
+    private lockPath;
+    private nextId;
+    private tasks;
+    constructor(listIdOrPath?: string);
+    private load;
+    private save;
+    private withLock;
+    create(subject: string, description: string, metadata?: Record<string, unknown>): TaskEntry;
+    get(id: string): TaskEntry | undefined;
+    list(): TaskEntry[];
+    update(id: string, fields: {
+        status?: TaskStatus;
+        subject?: string;
+        description?: string;
+    }): TaskEntry | undefined;
+    delete(id: string): boolean;
+    pendingCount(): number;
+    sweepCompleted(): number;
+}

package/dist/task-store.js

@@ -0,0 +1,181 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+const TASKS_DIR = join(homedir(), ".pi", "tasks");
+const LOCK_RETRY_MS = 50;
+const LOCK_MAX_RETRIES = 100;
+const MAX_TASKS = 200;
+function acquireLock(lockPath) {
+    for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
+        try {
+            writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
+            return;
+        }
+        catch (e) {
+            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) {
+    try {
+        unlinkSync(lockPath);
+    }
+    catch { /* ignore */ }
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export class TaskStore {
+    filePath;
+    lockPath;
+    nextId = 1;
+    tasks = new Map();
+    constructor(listIdOrPath) {
+        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();
+    }
+    load() {
+        if (!this.filePath)
+            return;
+        if (!existsSync(this.filePath))
+            return;
+        try {
+            const data = 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 */ }
+    }
+    save() {
+        if (!this.filePath)
+            return;
+        const data = {
+            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);
+    }
+    withLock(fn) {
+        if (!this.lockPath)
+            return fn();
+        acquireLock(this.lockPath);
+        try {
+            this.load();
+            const result = fn();
+            this.save();
+            return result;
+        }
+        finally {
+            releaseLock(this.lockPath);
+        }
+    }
+    create(subject, description, metadata) {
+        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 = {
+                id: String(this.nextId++),
+                subject,
+                description,
+                status: "pending",
+                createdAt: now,
+                updatedAt: now,
+                metadata,
+            };
+            this.tasks.set(entry.id, entry);
+            return entry;
+        });
+    }
+    get(id) {
+        if (this.filePath)
+            this.load();
+        return this.tasks.get(id);
+    }
+    list() {
+        if (this.filePath)
+            this.load();
+        return Array.from(this.tasks.values()).sort((a, b) => Number(a.id) - Number(b.id));
+    }
+    update(id, fields) {
+        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) {
+        return this.withLock(() => {
+            if (!this.tasks.has(id))
+                return false;
+            this.tasks.delete(id);
+            return true;
+        });
+    }
+    pendingCount() {
+        let count = 0;
+        for (const t of this.tasks.values()) {
+            if (t.status === "pending" || t.status === "in_progress")
+                count++;
+        }
+        return count;
+    }
+    sweepCompleted() {
+        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/dist/task-types.d.ts

@@ -0,0 +1,15 @@
+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/dist/task-types.js

@@ -0,0 +1 @@
+export {};

package/dist/trigger-system.d.ts

@@ -6,10 +6,11 @@ export declare class TriggerSystem {
     private pi;
     private scheduler;
     private store;
+    private onFire;
     private eventSubscriptions;
     private hybridTimers;
     private lastFireTime;
-    constructor(pi: ExtensionAPI, scheduler: CronScheduler, store: LoopStore);
+    constructor(pi: ExtensionAPI, scheduler: CronScheduler, store: LoopStore, onFire: (entry: LoopEntry) => void);
     start(): void;
     stop(): void;
     add(entry: LoopEntry): void;

package/dist/trigger-system.js

@@ -2,13 +2,15 @@ export class TriggerSystem {
     pi;
     scheduler;
     store;
+    onFire;
     eventSubscriptions = new Map();
     hybridTimers = new Map();
     lastFireTime = new Map();
-    constructor(pi, scheduler, store) {
+    constructor(pi, scheduler, store, onFire) {
         this.pi = pi;
         this.scheduler = scheduler;
         this.store = store;
+        this.onFire = onFire;
     }
     start() {
         this.scheduler.start();
@@ -89,25 +91,26 @@ export class TriggerSystem {
         this.hybridTimers.set(entry.id, timer);
     }
     fireLoop(entry) {
-        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);
         }
     }
     matchesFilter(data, filter) {

package/dist/ui/widget.d.ts

@@ -1,20 +1,22 @@
 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";
+interface TaskSummary {
+    count: number;
+    focusText?: string;
+}
 export declare class LoopWidget {
     private store;
-    private scheduler;
     private monitorManager;
     private uiCtx;
-    private tui;
-    private widgetRegistered;
     private interval;
-    constructor(store: LoopStore, scheduler: CronScheduler | undefined, monitorManager: MonitorManager);
+    private taskSummaryProvider;
+    constructor(store: LoopStore, monitorManager: MonitorManager);
     setUICtx(ctx: ExtensionUIContext): void;
     setStore(store: LoopStore): void;
-    setScheduler(scheduler: CronScheduler): void;
+    setTaskSummaryProvider(provider: (() => TaskSummary) | undefined): void;
     update(): void;
-    private renderWidget;
+    private computeStatus;
     dispose(): void;
 }
+export {};

package/dist/ui/widget.js

@@ -1,16 +1,11 @@
-import { truncateToWidth } from "@earendil-works/pi-tui";
-const MAX_VISIBLE = 6;
 export class LoopWidget {
     store;
-    scheduler;
     monitorManager;
     uiCtx;
-    tui;
-    widgetRegistered = false;
     interval;
-    constructor(store, scheduler, monitorManager) {
+    taskSummaryProvider;
+    constructor(store, monitorManager) {
         this.store = store;
-        this.scheduler = scheduler;
         this.monitorManager = monitorManager;
     }
     setUICtx(ctx) {
@@ -19,108 +14,49 @@ export class LoopWidget {
     setStore(store) {
         this.store = store;
     }
-    setScheduler(scheduler) {
-        this.scheduler = scheduler;
+    setTaskSummaryProvider(provider) {
+        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, theme) => {
-                this.tui = tui;
-                return { render: () => this.renderWidget(tui, theme), invalidate: () => { } };
-            }, { placement: "aboveEditor" });
-            this.widgetRegistered = true;
-        }
-        else if (this.tui) {
-            this.tui.requestRender();
+        if (!status && this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
         }
+        this.uiCtx.setStatus("loops", status);
     }
-    renderWidget(tui, _theme) {
+    computeStatus() {
         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) => truncateToWidth(line, w);
-        const lines = [];
-        const total = loops.length + allMonitors.length;
-        if (total === 0)
-            return [];
-        const headerParts = [`⟳ ${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(" · ")));
-        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}`));
-        }
-        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 monitors = this.monitorManager.list();
+        const taskSummary = this.taskSummaryProvider?.() ?? { count: 0 };
+        if (loops.length === 0 && monitors.length === 0 && taskSummary.count === 0) {
+            return undefined;
         }
-        return lines;
+        const parts = [];
+        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"));
+        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;
+        this.uiCtx?.setStatus("loops", undefined);
     }
 }
-function formatDuration(ms) {
-    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, noun) {
+    return `${count} ${noun}${count === 1 ? "" : "s"}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trevonistrevon/pi-loop",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "A pi extension for cron/event-based agent re-wake loops and background process monitoring.",
   "author": "trevonistrevon",
   "license": "MIT",