@trevonistrevon/pi-loop 0.5.0 → 0.5.2

package/dist/goal-store.d.ts

@@ -0,0 +1,33 @@
+import type { GoalCriteria, GoalEntry, GoalProgressSnapshot, GoalScope } from "./goal-types.js";
+export declare class GoalStore {
+    private filePath;
+    private lockPath;
+    private lastLoadedSignature;
+    private nextId;
+    private goals;
+    constructor(listIdOrPath?: string);
+    private getFileSignature;
+    private load;
+    private save;
+    private withLock;
+    private toReducerState;
+    private applyReducerEvent;
+    create(title: string, description: string, scope: GoalScope, criteria: GoalCriteria, metadata?: Record<string, unknown>): GoalEntry;
+    get(id: string): GoalEntry | undefined;
+    list(): GoalEntry[];
+    activate(id: string): GoalEntry | undefined;
+    recordProgress(id: string, progress: GoalProgressSnapshot): GoalEntry | undefined;
+    markVerificationStarted(id: string): GoalEntry | undefined;
+    markVerified(id: string, reason: string, progress?: GoalProgressSnapshot): GoalEntry | undefined;
+    markFailed(id: string, reason: string, progress?: GoalProgressSnapshot): GoalEntry | undefined;
+    markBlocked(id: string, reason: string, progress?: GoalProgressSnapshot): GoalEntry | undefined;
+    unblock(id: string): GoalEntry | undefined;
+    updateDetails(id: string, fields: {
+        title?: string;
+        description?: string;
+        scope?: GoalScope;
+        criteria?: GoalCriteria;
+        metadata?: Record<string, unknown>;
+    }): GoalEntry | undefined;
+    archive(id: string, reason?: string): GoalEntry | undefined;
+}

package/dist/goal-store.js

@@ -0,0 +1,310 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import { reduceGoalState } from "./goal-reducer.js";
+const GOALS_DIR = join(homedir(), ".pi", "goals");
+const LOCK_RETRY_MS = 50;
+const LOCK_MAX_RETRIES = 100;
+const MAX_GOALS = 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 GoalStore {
+    filePath;
+    lockPath;
+    lastLoadedSignature;
+    nextId = 1;
+    goals = new Map();
+    constructor(listIdOrPath) {
+        if (!listIdOrPath)
+            return;
+        const isAbsPath = isAbsolute(listIdOrPath);
+        const filePath = isAbsPath ? listIdOrPath : join(GOALS_DIR, `${listIdOrPath}.json`);
+        mkdirSync(dirname(filePath), { recursive: true });
+        this.filePath = filePath;
+        this.lockPath = filePath + ".lock";
+        this.load();
+    }
+    getFileSignature() {
+        if (!this.filePath || !existsSync(this.filePath))
+            return undefined;
+        const stat = statSync(this.filePath);
+        return `${stat.mtimeMs}:${stat.size}`;
+    }
+    load(force = false) {
+        if (!this.filePath)
+            return;
+        const signature = this.getFileSignature();
+        if (!signature)
+            return;
+        if (!force && signature === this.lastLoadedSignature)
+            return;
+        try {
+            const data = JSON.parse(readFileSync(this.filePath, "utf-8"));
+            this.nextId = data.nextId;
+            this.goals.clear();
+            for (const goal of data.goals) {
+                this.goals.set(goal.id, goal);
+            }
+            this.lastLoadedSignature = signature;
+        }
+        catch { /* corrupt file — start fresh */ }
+    }
+    save() {
+        if (!this.filePath)
+            return;
+        const data = {
+            nextId: this.nextId,
+            goals: Array.from(this.goals.values()),
+        };
+        const tmpPath = this.filePath + ".tmp";
+        writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+        renameSync(tmpPath, this.filePath);
+        this.lastLoadedSignature = this.getFileSignature();
+    }
+    withLock(fn) {
+        if (!this.lockPath)
+            return fn();
+        acquireLock(this.lockPath);
+        try {
+            this.load(true);
+            const result = fn();
+            this.save();
+            return result;
+        }
+        finally {
+            releaseLock(this.lockPath);
+        }
+    }
+    toReducerState() {
+        return {
+            nextId: this.nextId,
+            goalsById: Object.fromEntries(this.goals.entries()),
+        };
+    }
+    applyReducerEvent(event) {
+        const result = reduceGoalState(this.toReducerState(), event);
+        this.nextId = result.state.nextId;
+        this.goals = new Map(Object.entries(result.state.goalsById));
+    }
+    create(title, description, scope, criteria, metadata) {
+        return this.withLock(() => {
+            if (this.goals.size >= MAX_GOALS) {
+                throw new Error(`Maximum of ${MAX_GOALS} goals reached. Archive some before creating new ones.`);
+            }
+            this.applyReducerEvent({
+                type: "GOAL_CREATED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "goal",
+                payload: {
+                    title,
+                    description,
+                    scope,
+                    criteria,
+                    metadata,
+                },
+            });
+            return this.goals.get(String(this.nextId - 1));
+        });
+    }
+    get(id) {
+        if (this.filePath)
+            this.load();
+        return this.goals.get(id);
+    }
+    list() {
+        if (this.filePath)
+            this.load();
+        return Array.from(this.goals.values()).sort((a, b) => Number(a.id) - Number(b.id));
+    }
+    activate(id) {
+        return this.withLock(() => {
+            if (!this.goals.has(id))
+                return undefined;
+            this.applyReducerEvent({
+                type: "GOAL_ACTIVATED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "goal",
+                entityId: id,
+                payload: { id },
+            });
+            return this.goals.get(id);
+        });
+    }
+    recordProgress(id, progress) {
+        return this.withLock(() => {
+            if (!this.goals.has(id))
+                return undefined;
+            this.applyReducerEvent({
+                type: "GOAL_PROGRESS_RECORDED",
+                at: Date.now(),
+                source: "coordinator",
+                entityType: "goal",
+                entityId: id,
+                payload: { id, progress },
+            });
+            return this.goals.get(id);
+        });
+    }
+    markVerificationStarted(id) {
+        return this.withLock(() => {
+            if (!this.goals.has(id))
+                return undefined;
+            this.applyReducerEvent({
+                type: "GOAL_VERIFICATION_STARTED",
+                at: Date.now(),
+                source: "coordinator",
+                entityType: "goal",
+                entityId: id,
+                payload: { id },
+            });
+            return this.goals.get(id);
+        });
+    }
+    markVerified(id, reason, progress) {
+        return this.withLock(() => {
+            if (!this.goals.has(id))
+                return undefined;
+            this.applyReducerEvent({
+                type: "GOAL_VERIFICATION_PASSED",
+                at: Date.now(),
+                source: "coordinator",
+                entityType: "goal",
+                entityId: id,
+                payload: { id, reason, progress },
+            });
+            return this.goals.get(id);
+        });
+    }
+    markFailed(id, reason, progress) {
+        return this.withLock(() => {
+            if (!this.goals.has(id))
+                return undefined;
+            this.applyReducerEvent({
+                type: "GOAL_FAILED",
+                at: Date.now(),
+                source: "coordinator",
+                entityType: "goal",
+                entityId: id,
+                payload: { id, reason, progress },
+            });
+            return this.goals.get(id);
+        });
+    }
+    markBlocked(id, reason, progress) {
+        return this.withLock(() => {
+            if (!this.goals.has(id))
+                return undefined;
+            this.applyReducerEvent({
+                type: "GOAL_BLOCKED",
+                at: Date.now(),
+                source: "coordinator",
+                entityType: "goal",
+                entityId: id,
+                payload: { id, reason, progress },
+            });
+            return this.goals.get(id);
+        });
+    }
+    unblock(id) {
+        return this.withLock(() => {
+            if (!this.goals.has(id))
+                return undefined;
+            this.applyReducerEvent({
+                type: "GOAL_UNBLOCKED",
+                at: Date.now(),
+                source: "coordinator",
+                entityType: "goal",
+                entityId: id,
+                payload: { id },
+            });
+            return this.goals.get(id);
+        });
+    }
+    updateDetails(id, fields) {
+        return this.withLock(() => {
+            if (!this.goals.has(id))
+                return undefined;
+            if (fields.title === undefined
+                && fields.description === undefined
+                && fields.scope === undefined
+                && fields.criteria === undefined
+                && fields.metadata === undefined) {
+                return this.goals.get(id);
+            }
+            this.applyReducerEvent({
+                type: "GOAL_UPDATED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "goal",
+                entityId: id,
+                payload: {
+                    id,
+                    title: fields.title,
+                    description: fields.description,
+                    scope: fields.scope,
+                    criteria: fields.criteria,
+                    metadata: fields.metadata,
+                },
+            });
+            return this.goals.get(id);
+        });
+    }
+    archive(id, reason) {
+        return this.withLock(() => {
+            if (!this.goals.has(id))
+                return undefined;
+            this.applyReducerEvent({
+                type: "GOAL_ARCHIVED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "goal",
+                entityId: id,
+                payload: { id, reason },
+            });
+            return this.goals.get(id);
+        });
+    }
+}

package/dist/goal-types.d.ts

@@ -76,3 +76,7 @@ export interface GoalReducerState {
     nextId: number;
     goalsById: Record<string, GoalEntry>;
 }
+export interface GoalStoreData {
+    nextId: number;
+    goals: GoalEntry[];
+}