@trevonistrevon/pi-loop 0.5.9 → 0.6.1

package/dist/goal-reducer.js

@@ -1,190 +0,0 @@
-function cloneState(state) {
-    return {
-        nextId: state.nextId,
-        goalsById: { ...state.goalsById },
-    };
-}
-function emptyProgress() {
-    return {
-        totalTasks: 0,
-        pendingTasks: 0,
-        inProgressTasks: 0,
-        completedTasks: 0,
-        activeLoops: 0,
-        pausedLoops: 0,
-        runningMonitors: 0,
-        completedMonitors: 0,
-        erroredMonitors: 0,
-        stoppedMonitors: 0,
-    };
-}
-function emptyVerification() {
-    return {
-        attempts: 0,
-        passes: 0,
-        failures: 0,
-    };
-}
-function persist(goal) {
-    return {
-        type: "PERSIST_GOAL",
-        entityType: "goal",
-        entityId: goal.id,
-        payload: { goal },
-    };
-}
-function isTerminal(goal) {
-    return goal.status === "satisfied" || goal.status === "failed" || goal.status === "archived";
-}
-export function reduceGoalState(state, event) {
-    if (event.type === "GOAL_CREATED") {
-        const next = cloneState(state);
-        const id = String(next.nextId++);
-        const goal = {
-            id,
-            title: event.payload.title,
-            description: event.payload.description,
-            status: "pending",
-            verificationStatus: "unknown",
-            createdAt: event.at,
-            updatedAt: event.at,
-            scope: event.payload.scope,
-            criteria: event.payload.criteria,
-            progress: emptyProgress(),
-            verification: emptyVerification(),
-            metadata: event.payload.metadata,
-        };
-        next.goalsById[id] = goal;
-        return {
-            state: next,
-            effects: [persist(goal)],
-        };
-    }
-    const id = event.payload.id;
-    const current = state.goalsById[id];
-    if (!current)
-        return { state, effects: [] };
-    if (isTerminal(current) && event.type !== "GOAL_ARCHIVED") {
-        return {
-            state,
-            effects: [{
-                    type: "GOAL_TRANSITION_REJECTED",
-                    entityType: "goal",
-                    entityId: id,
-                    payload: { id, status: current.status, attempted: event.type },
-                }],
-        };
-    }
-    const next = cloneState(state);
-    const goal = {
-        ...current,
-        progress: { ...current.progress },
-        verification: { ...current.verification },
-    };
-    let extraEffects = [];
-    if (event.type === "GOAL_ACTIVATED") {
-        goal.status = "active";
-        goal.activatedAt ??= event.at;
-        goal.updatedAt = event.at;
-        extraEffects = [{
-                type: "REQUEST_GOAL_VERIFICATION",
-                entityType: "goal",
-                entityId: id,
-                payload: { id },
-            }];
-    }
-    if (event.type === "GOAL_PROGRESS_RECORDED") {
-        goal.progress = event.payload.progress;
-        goal.updatedAt = event.at;
-    }
-    if (event.type === "GOAL_VERIFICATION_STARTED") {
-        goal.verificationStatus = "checking";
-        goal.verification.attempts += 1;
-        goal.verification.lastCheckedAt = event.at;
-        goal.updatedAt = event.at;
-    }
-    if (event.type === "GOAL_VERIFICATION_PASSED") {
-        if (event.payload.progress)
-            goal.progress = event.payload.progress;
-        goal.status = "satisfied";
-        goal.verificationStatus = "verified";
-        goal.verification.passes += 1;
-        goal.verification.lastPassedAt = event.at;
-        goal.verification.lastCheckedAt = event.at;
-        goal.verification.lastReason = event.payload.reason;
-        goal.resolvedAt = event.at;
-        goal.updatedAt = event.at;
-    }
-    if (event.type === "GOAL_VERIFICATION_FAILED") {
-        if (event.payload.progress)
-            goal.progress = event.payload.progress;
-        goal.verificationStatus = "unverified";
-        goal.verification.failures += 1;
-        goal.verification.lastFailedAt = event.at;
-        goal.verification.lastCheckedAt = event.at;
-        goal.verification.lastReason = event.payload.reason;
-        if (goal.status === "pending")
-            goal.status = "active";
-        goal.updatedAt = event.at;
-    }
-    if (event.type === "GOAL_BLOCKED") {
-        if (event.payload.progress)
-            goal.progress = event.payload.progress;
-        goal.status = "blocked";
-        goal.verificationStatus = "inconclusive";
-        goal.verification.failures += 1;
-        goal.verification.lastFailedAt = event.at;
-        goal.verification.lastCheckedAt = event.at;
-        goal.verification.lastReason = event.payload.reason;
-        goal.updatedAt = event.at;
-    }
-    if (event.type === "GOAL_UNBLOCKED") {
-        goal.status = "active";
-        goal.updatedAt = event.at;
-    }
-    if (event.type === "GOAL_SATISFIED") {
-        goal.status = "satisfied";
-        goal.verificationStatus = "verified";
-        goal.verification.lastReason = event.payload.reason ?? goal.verification.lastReason;
-        goal.resolvedAt = event.at;
-        goal.updatedAt = event.at;
-    }
-    if (event.type === "GOAL_FAILED") {
-        if (event.payload.progress)
-            goal.progress = event.payload.progress;
-        goal.status = "failed";
-        goal.verificationStatus = "unverified";
-        goal.verification.failures += 1;
-        goal.verification.lastFailedAt = event.at;
-        goal.verification.lastCheckedAt = event.at;
-        goal.verification.lastReason = event.payload.reason;
-        goal.resolvedAt = event.at;
-        goal.updatedAt = event.at;
-    }
-    if (event.type === "GOAL_ARCHIVED") {
-        goal.status = "archived";
-        goal.resolvedAt = event.at;
-        goal.updatedAt = event.at;
-        if (event.payload.reason !== undefined) {
-            goal.verification.lastReason = event.payload.reason;
-        }
-    }
-    if (event.type === "GOAL_UPDATED") {
-        if (event.payload.title !== undefined)
-            goal.title = event.payload.title;
-        if (event.payload.description !== undefined)
-            goal.description = event.payload.description;
-        if (event.payload.scope !== undefined)
-            goal.scope = event.payload.scope;
-        if (event.payload.criteria !== undefined)
-            goal.criteria = event.payload.criteria;
-        if (event.payload.metadata !== undefined)
-            goal.metadata = event.payload.metadata;
-        goal.updatedAt = event.at;
-    }
-    next.goalsById[id] = goal;
-    return {
-        state: next,
-        effects: [persist(goal), ...extraEffects],
-    };
-}

package/dist/goal-store.d.ts

@@ -1,22 +0,0 @@
-import { type GoalReducerEvent } from "./goal-reducer.js";
-import type { GoalCriteria, GoalEntry, GoalProgressSnapshot, GoalReducerState, GoalScope, GoalStoreData } from "./goal-types.js";
-import { ReducerBackedStore } from "./reducer-backed-store.js";
-export declare class GoalStore extends ReducerBackedStore<GoalEntry, GoalReducerState, GoalReducerEvent, GoalStoreData> {
-    constructor(listIdOrPath?: string);
-    create(title: string, description: string, scope: GoalScope, criteria: GoalCriteria, metadata?: Record<string, unknown>): 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

@@ -1,188 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { reduceGoalState } from "./goal-reducer.js";
-import { ReducerBackedStore } from "./reducer-backed-store.js";
-const GOALS_DIR = join(homedir(), ".pi", "goals");
-const MAX_GOALS = 200;
-export class GoalStore extends ReducerBackedStore {
-    constructor(listIdOrPath) {
-        super({
-            baseDir: GOALS_DIR,
-            reduce: (state, event) => reduceGoalState(state, event),
-            toReducerState: (nextId, entries) => ({ nextId, goalsById: Object.fromEntries(entries.entries()) }),
-            fromReducerState: (state) => ({ nextId: state.nextId, entries: new Map(Object.entries(state.goalsById)) }),
-            serialize: (nextId, entries) => ({ nextId, goals: Array.from(entries.values()) }),
-            deserialize: (data) => ({ nextId: data.nextId, entries: new Map(data.goals.map((g) => [g.id, g])) }),
-        }, listIdOrPath);
-    }
-    create(title, description, scope, criteria, metadata) {
-        return this.withLock(() => {
-            if (this.entries.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.entries.get(String(this.nextId - 1));
-        });
-    }
-    activate(id) {
-        return this.withLock(() => {
-            if (!this.entries.has(id))
-                return undefined;
-            this.applyReducerEvent({
-                type: "GOAL_ACTIVATED",
-                at: Date.now(),
-                source: "tool",
-                entityType: "goal",
-                entityId: id,
-                payload: { id },
-            });
-            return this.entries.get(id);
-        });
-    }
-    recordProgress(id, progress) {
-        return this.withLock(() => {
-            if (!this.entries.has(id))
-                return undefined;
-            this.applyReducerEvent({
-                type: "GOAL_PROGRESS_RECORDED",
-                at: Date.now(),
-                source: "coordinator",
-                entityType: "goal",
-                entityId: id,
-                payload: { id, progress },
-            });
-            return this.entries.get(id);
-        });
-    }
-    markVerificationStarted(id) {
-        return this.withLock(() => {
-            if (!this.entries.has(id))
-                return undefined;
-            this.applyReducerEvent({
-                type: "GOAL_VERIFICATION_STARTED",
-                at: Date.now(),
-                source: "coordinator",
-                entityType: "goal",
-                entityId: id,
-                payload: { id },
-            });
-            return this.entries.get(id);
-        });
-    }
-    markVerified(id, reason, progress) {
-        return this.withLock(() => {
-            if (!this.entries.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.entries.get(id);
-        });
-    }
-    markFailed(id, reason, progress) {
-        return this.withLock(() => {
-            if (!this.entries.has(id))
-                return undefined;
-            this.applyReducerEvent({
-                type: "GOAL_FAILED",
-                at: Date.now(),
-                source: "coordinator",
-                entityType: "goal",
-                entityId: id,
-                payload: { id, reason, progress },
-            });
-            return this.entries.get(id);
-        });
-    }
-    markBlocked(id, reason, progress) {
-        return this.withLock(() => {
-            if (!this.entries.has(id))
-                return undefined;
-            this.applyReducerEvent({
-                type: "GOAL_BLOCKED",
-                at: Date.now(),
-                source: "coordinator",
-                entityType: "goal",
-                entityId: id,
-                payload: { id, reason, progress },
-            });
-            return this.entries.get(id);
-        });
-    }
-    unblock(id) {
-        return this.withLock(() => {
-            if (!this.entries.has(id))
-                return undefined;
-            this.applyReducerEvent({
-                type: "GOAL_UNBLOCKED",
-                at: Date.now(),
-                source: "coordinator",
-                entityType: "goal",
-                entityId: id,
-                payload: { id },
-            });
-            return this.entries.get(id);
-        });
-    }
-    updateDetails(id, fields) {
-        return this.withLock(() => {
-            if (!this.entries.has(id))
-                return undefined;
-            if (fields.title === undefined
-                && fields.description === undefined
-                && fields.scope === undefined
-                && fields.criteria === undefined
-                && fields.metadata === undefined) {
-                return this.entries.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.entries.get(id);
-        });
-    }
-    archive(id, reason) {
-        return this.withLock(() => {
-            if (!this.entries.has(id))
-                return undefined;
-            this.applyReducerEvent({
-                type: "GOAL_ARCHIVED",
-                at: Date.now(),
-                source: "tool",
-                entityType: "goal",
-                entityId: id,
-                payload: { id, reason },
-            });
-            return this.entries.get(id);
-        });
-    }
-}

package/dist/goal-types.d.ts

@@ -1,82 +0,0 @@
-export type GoalStatus = "pending" | "active" | "satisfied" | "blocked" | "failed" | "archived";
-export type GoalVerificationStatus = "unknown" | "checking" | "verified" | "unverified" | "inconclusive";
-export interface GoalScope {
-    taskIds?: string[];
-    loopIds?: string[];
-    monitorIds?: string[];
-    tags?: string[];
-    subjectPrefixes?: string[];
-    includeFutureMatchingTasks?: boolean;
-    includeFutureMatchingLoops?: boolean;
-    includeFutureMatchingMonitors?: boolean;
-}
-export interface GoalSuccessCriteria {
-    minCompletedTasks?: number;
-    requiredTaskIds?: string[];
-    requiredMonitorIdsCompleted?: string[];
-    requiredLoopIdsPresent?: string[];
-    requireNoPendingTasksInScope?: boolean;
-    requireLatestVerificationPass?: boolean;
-}
-export interface GoalFailureCriteria {
-    anyMonitorIdsErrored?: string[];
-    maxVerificationFailures?: number;
-    failIfTaskIdsDeleted?: string[];
-}
-export interface GoalBlockedCriteria {
-    blockedIfAllTasksCompletedButVerificationFails?: boolean;
-    blockedIfNoScopedProgressSinceMs?: number;
-    blockedIfRequiredLoopMissing?: boolean;
-}
-export interface GoalCriteria {
-    success: GoalSuccessCriteria;
-    failure?: GoalFailureCriteria;
-    blocked?: GoalBlockedCriteria;
-}
-export interface GoalProgressSnapshot {
-    totalTasks: number;
-    pendingTasks: number;
-    inProgressTasks: number;
-    completedTasks: number;
-    activeLoops: number;
-    pausedLoops: number;
-    runningMonitors: number;
-    completedMonitors: number;
-    erroredMonitors: number;
-    stoppedMonitors: number;
-    lastProgressAt?: number;
-}
-export interface GoalVerificationState {
-    attempts: number;
-    passes: number;
-    failures: number;
-    lastCheckedAt?: number;
-    lastPassedAt?: number;
-    lastFailedAt?: number;
-    lastReason?: string;
-    nextCheckAfter?: number;
-}
-export interface GoalEntry {
-    id: string;
-    title: string;
-    description: string;
-    status: GoalStatus;
-    verificationStatus: GoalVerificationStatus;
-    createdAt: number;
-    updatedAt: number;
-    activatedAt?: number;
-    resolvedAt?: number;
-    scope: GoalScope;
-    criteria: GoalCriteria;
-    progress: GoalProgressSnapshot;
-    verification: GoalVerificationState;
-    metadata?: Record<string, unknown>;
-}
-export interface GoalReducerState {
-    nextId: number;
-    goalsById: Record<string, GoalEntry>;
-}
-export interface GoalStoreData {
-    nextId: number;
-    goals: GoalEntry[];
-}

package/dist/goal-types.js

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

package/dist/goal-verifier.d.ts

@@ -1,20 +0,0 @@
-import type { ReducerEffect } from "./coordinator.js";
-import type { GoalEntry, GoalProgressSnapshot } from "./goal-types.js";
-import type { LoopReducerState } from "./loop-reducer.js";
-import type { MonitorReducerState } from "./monitor-reducer.js";
-import type { TaskReducerState } from "./task-reducer.js";
-export interface GoalVerifierInput {
-    goal: GoalEntry;
-    taskState: TaskReducerState;
-    loopState: LoopReducerState;
-    monitorState: MonitorReducerState;
-    at: number;
-}
-export interface GoalVerifierResult {
-    progress: GoalProgressSnapshot;
-    verdict: "passed" | "failed" | "blocked";
-    reason: string;
-    effects: ReducerEffect[];
-}
-export declare function projectGoalProgress(goal: GoalEntry, taskState: TaskReducerState, loopState: LoopReducerState, monitorState: MonitorReducerState): GoalProgressSnapshot;
-export declare function verifyGoal(input: GoalVerifierInput): GoalVerifierResult;