@trevonistrevon/pi-loop 0.5.0 → 0.5.1

package/src/commands/loop-command.ts

@@ -0,0 +1,184 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionUIContext,
+} from "@earendil-works/pi-coding-agent";
+import { parseInterval } from "../loop-parse.js";
+import type { LoopEntry, Trigger } from "../types.js";
+
+interface LoopStoreLike {
+  list(): LoopEntry[];
+  get(id: string): LoopEntry | undefined;
+  create(trigger: Trigger, prompt: string, options?: Partial<LoopEntry>): LoopEntry;
+  pause(id: string): LoopEntry | undefined;
+  resume(id: string): LoopEntry | undefined;
+  delete(id: string): boolean;
+}
+
+interface TriggerSystemLike {
+  add(entry: LoopEntry): void;
+  remove(id: string): void;
+}
+
+export interface LoopCommandOptions {
+  pi: ExtensionAPI;
+  getStore: () => LoopStoreLike;
+  getTriggerSystem: () => TriggerSystemLike;
+  updateWidget: () => void;
+}
+
+export function registerLoopCommand(options: LoopCommandOptions): void {
+  const { pi, getStore, getTriggerSystem, updateWidget } = options;
+
+  async function scheduleLoop(ui: ExtensionUIContext, prompt?: string) {
+    const p = prompt || await ui.input("Prompt (what should the agent check?)");
+    if (!p) return;
+
+    const interval = await ui.input("Interval (e.g., 5m, 2h, 1d)");
+    if (!interval) return;
+
+    try {
+      const parsed = parseInterval(interval);
+      const trigger: Trigger = { type: "cron", schedule: parsed.cron };
+      const entry = getStore().create(trigger, p, { recurring: true });
+      getTriggerSystem().add(entry);
+      updateWidget();
+      ui.notify(`Loop #${entry.id} created: every ${parsed.description}`, "info");
+    } catch (err: unknown) {
+      ui.notify((err as Error).message, "error");
+    }
+  }
+
+  async function eventLoop(ui: ExtensionUIContext, prompt?: string) {
+    const p = prompt || await ui.input("Prompt");
+    if (!p) return;
+
+    const source = await ui.input("Pi event source (e.g., tool_execution_start, before_agent_start)");
+    if (!source) return;
+
+    const trigger: Trigger = { type: "event", source };
+    const entry = getStore().create(trigger, p, { recurring: true });
+    getTriggerSystem().add(entry);
+    updateWidget();
+    ui.notify(`Event loop #${entry.id} created: fires on "${source}"`, "info");
+  }
+
+  async function viewLoops(ui: ExtensionUIContext) {
+    const loops = getStore().list();
+    if (loops.length === 0) {
+      await ui.select("No active loops", ["< Back"]);
+      return;
+    }
+
+    const choices = loops.map((l) => {
+      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");
+
+    const selected = await ui.select("Active Loops", choices);
+    if (!selected || selected === "< Back") return;
+
+    const match = selected.match(/#(\d+)/);
+    if (match) {
+      const entry = getStore().get(match[1]);
+      if (entry) {
+        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 === "x Delete") {
+          getTriggerSystem().remove(entry.id);
+          getStore().delete(entry.id);
+          updateWidget();
+          ui.notify(`Loop #${entry.id} deleted`, "info");
+        } else if (action === "- Pause") {
+          getStore().pause(entry.id);
+          getTriggerSystem().remove(entry.id);
+          updateWidget();
+          ui.notify(`Loop #${entry.id} paused`, "info");
+        } else if (action === "* Resume") {
+          getStore().resume(entry.id);
+          getTriggerSystem().add(entry);
+          updateWidget();
+          ui.notify(`Loop #${entry.id} resumed`, "info");
+        }
+      }
+    }
+
+    return viewLoops(ui);
+  }
+
+  async function settings(ui: ExtensionUIContext) {
+    const loops = getStore().list();
+    const active = loops.filter((l) => l.status === "active").length;
+    ui.notify(`${active}/${loops.length} active loops (max 25)`, "info");
+  }
+
+  pi.registerCommand("loop", {
+    description: "Create a repeating scheduled task: /loop [interval] [prompt]. E.g., /loop 5m check the deploy, /loop 30s am I still here",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const trimmed = args.trim();
+      const ui = ctx.ui;
+
+      if (!trimmed) {
+        const choice = await ui.select("Loop", [
+          "Create scheduled loop",
+          "Create event-triggered loop",
+          "View active loops",
+          "Settings",
+        ]);
+
+        if (!choice) return;
+        if (choice.startsWith("Create scheduled")) return scheduleLoop(ui);
+        if (choice.startsWith("Create event")) return eventLoop(ui);
+        if (choice.startsWith("View active")) return viewLoops(ui);
+        return settings(ui);
+      }
+
+      const intervalMatch = trimmed.match(/^(\d+\s*[smhdS]\b)/i);
+      if (intervalMatch) {
+        const interval = intervalMatch[1];
+        const prompt = trimmed.slice(intervalMatch[0].length).trim();
+
+        if (!prompt) {
+          ui.notify("Provide a prompt after the interval, e.g., /loop 5m check the deploy", "warning");
+          return;
+        }
+
+        try {
+          const parsed = parseInterval(interval);
+          const trigger: Trigger = { type: "cron", schedule: parsed.cron };
+          const entry = getStore().create(trigger, prompt, { recurring: true });
+          getTriggerSystem().add(entry);
+          updateWidget();
+          ui.notify(`Loop #${entry.id} created: every ${parsed.description} — ${prompt.slice(0, 50)}`, "info");
+        } catch (err: unknown) {
+          ui.notify((err as Error).message, "error");
+        }
+        return;
+      }
+
+      const choice = await ui.select("Loop mode", [
+        `Scheduled: "${trimmed.slice(0, 50)}"`,
+        `Event-triggered: "${trimmed.slice(0, 50)}"`,
+        `Self-paced: "${trimmed.slice(0, 50)}"`,
+      ]);
+
+      if (!choice) return;
+      if (choice.startsWith("Event")) return eventLoop(ui, trimmed);
+      return scheduleLoop(ui, trimmed);
+    },
+  });
+}

package/src/commands/tasks-command.ts

@@ -0,0 +1,135 @@
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { TaskStore } from "../task-store.js";
+import type { TaskEntry } from "../task-types.js";
+
+export interface TaskBacklogResult {
+  created: boolean;
+  entry?: { id: string };
+}
+
+export interface TasksCommandOptions {
+  pi: ExtensionAPI;
+  getNativeTaskStore: () => TaskStore | undefined;
+  evaluateTaskBacklog: (taskStore: TaskStore, pendingCount: number) => Promise<TaskBacklogResult>;
+  updateWidget: () => void;
+}
+
+export function registerTasksCommand(options: TasksCommandOptions): void {
+  const { pi, getNativeTaskStore, evaluateTaskBacklog, updateWidget } = options;
+
+  async function emitCreated(entry: TaskEntry) {
+    pi.events.emit("tasks:created", {
+      taskId: entry.id,
+      subject: entry.subject,
+      description: entry.description,
+      status: entry.status,
+    });
+    const taskStore = getNativeTaskStore();
+    if (!taskStore) return { created: false } satisfies TaskBacklogResult;
+    const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
+    updateWidget();
+    return backlog;
+  }
+
+  async function createNativeTaskInteractively(ui: ExtensionUIContext) {
+    const taskStore = getNativeTaskStore();
+    if (!taskStore) {
+      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 = taskStore.create(subject, description);
+    const backlog = await emitCreated(entry);
+    ui.notify(`Task #${entry.id} created`, "info");
+    if (backlog.created && backlog.entry) {
+      ui.notify(`Worker loop #${backlog.entry.id} auto-created`, "info");
+    }
+  }
+
+  async function viewNativeTasks(ui: ExtensionUIContext): Promise<void> {
+    const taskStore = getNativeTaskStore();
+    if (!taskStore) {
+      ui.notify("Native tasks are unavailable while pi-tasks is active", "warning");
+      return;
+    }
+
+    const tasks = taskStore.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 = taskStore.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") {
+      taskStore.delete(task.id);
+      ui.notify(`Task #${task.id} deleted`, "info");
+    } else if (action === "> Start") {
+      taskStore.start(task.id);
+      ui.notify(`Task #${task.id} started`, "info");
+    } else if (action === "ok Complete") {
+      taskStore.complete(task.id);
+      ui.notify(`Task #${task.id} completed`, "info");
+    } else if (action === "* Return to pending" || action === "* Reopen") {
+      taskStore.reopen(task.id);
+      ui.notify(`Task #${task.id} reopened`, "info");
+    }
+
+    updateWidget();
+    await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
+    return viewNativeTasks(ui);
+  }
+
+  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();
+      const taskStore = getNativeTaskStore();
+      if (!taskStore) {
+        ctx.ui.notify("Native tasks are unavailable while pi-tasks is active", "warning");
+        return;
+      }
+      if (trimmed) {
+        const entry = taskStore.create(trimmed.slice(0, 80), trimmed);
+        const backlog = await emitCreated(entry);
+        ctx.ui.notify(`Task #${entry.id} created`, "info");
+        if (backlog.created && backlog.entry) {
+          ctx.ui.notify(`Worker loop #${backlog.entry.id} auto-created`, "info");
+        }
+        return;
+      }
+      await viewNativeTasks(ctx.ui);
+    },
+  });
+}

package/src/goal-coordinator.ts

@@ -0,0 +1,58 @@
+import type { ReducerEffect, ReducerEvent } from "./coordinator.js";
+import type { GoalReducerState } from "./goal-types.js";
+import { verifyGoal } from "./goal-verifier.js";
+import type { LoopReducerState } from "./loop-reducer.js";
+import type { MonitorReducerState } from "./monitor-reducer.js";
+import type { TaskReducerState } from "./task-reducer.js";
+
+export type GoalVerificationRequestedEvent = ReducerEvent<
+  "GOAL_VERIFICATION_REQUESTED",
+  { id: string }
+>;
+
+export interface GoalCoordinatorSnapshot {
+  goalState: GoalReducerState;
+  taskState: TaskReducerState;
+  loopState: LoopReducerState;
+  monitorState: MonitorReducerState;
+}
+
+export function reduceGoalVerificationRequest(
+  event: GoalVerificationRequestedEvent,
+  snapshot: GoalCoordinatorSnapshot,
+): ReducerEffect[] {
+  if (event.type !== "GOAL_VERIFICATION_REQUESTED") return [];
+
+  const goal = snapshot.goalState.goalsById[event.payload.id];
+  if (!goal) return [];
+
+  return verifyGoal({
+    goal,
+    taskState: snapshot.taskState,
+    loopState: snapshot.loopState,
+    monitorState: snapshot.monitorState,
+    at: event.at,
+  }).effects;
+}
+
+export interface GoalCoordinatorOptions {
+  getGoalState: () => GoalReducerState;
+  getTaskState: () => TaskReducerState;
+  getLoopState: () => LoopReducerState;
+  getMonitorState: () => MonitorReducerState;
+}
+
+export function createGoalCoordinatorReducer(options: GoalCoordinatorOptions) {
+  const { getGoalState, getTaskState, getLoopState, getMonitorState } = options;
+
+  return (event: ReducerEvent): ReducerEffect[] => {
+    if (event.type !== "GOAL_VERIFICATION_REQUESTED") return [];
+
+    return reduceGoalVerificationRequest(event as GoalVerificationRequestedEvent, {
+      goalState: getGoalState(),
+      taskState: getTaskState(),
+      loopState: getLoopState(),
+      monitorState: getMonitorState(),
+    });
+  };
+}

package/src/goal-reducer.ts

@@ -0,0 +1,280 @@
+import type {
+  GoalCriteria,
+  GoalEntry,
+  GoalProgressSnapshot,
+  GoalReducerState,
+  GoalScope,
+  GoalVerificationState,
+} from "./goal-types.js";
+
+export type GoalReducerEvent =
+  | {
+    type: "GOAL_CREATED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "goal";
+    entityId?: string;
+    payload: {
+      title: string;
+      description: string;
+      scope: GoalScope;
+      criteria: GoalCriteria;
+      metadata?: Record<string, unknown>;
+    };
+  }
+  | {
+    type: "GOAL_ACTIVATED" | "GOAL_VERIFICATION_STARTED" | "GOAL_UNBLOCKED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "goal";
+    entityId?: string;
+    payload: { id: string };
+  }
+  | {
+    type: "GOAL_PROGRESS_RECORDED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "goal";
+    entityId?: string;
+    payload: { id: string; progress: GoalProgressSnapshot };
+  }
+  | {
+    type: "GOAL_VERIFICATION_PASSED" | "GOAL_VERIFICATION_FAILED" | "GOAL_BLOCKED" | "GOAL_FAILED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "goal";
+    entityId?: string;
+    payload: { id: string; reason: string; progress?: GoalProgressSnapshot };
+  }
+  | {
+    type: "GOAL_SATISFIED" | "GOAL_ARCHIVED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "goal";
+    entityId?: string;
+    payload: { id: string; reason?: string };
+  }
+  | {
+    type: "GOAL_UPDATED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "goal";
+    entityId?: string;
+    payload: {
+      id: string;
+      title?: string;
+      description?: string;
+      scope?: GoalScope;
+      criteria?: GoalCriteria;
+      metadata?: Record<string, unknown>;
+    };
+  };
+
+export type GoalReducerEffect =
+  | {
+    type: "PERSIST_GOAL";
+    entityType: "goal";
+    entityId: string;
+    payload: { goal: GoalEntry };
+  }
+  | {
+    type: "REQUEST_GOAL_VERIFICATION";
+    entityType: "goal";
+    entityId: string;
+    payload: { id: string };
+  };
+
+export interface GoalReduceResult {
+  state: GoalReducerState;
+  effects: GoalReducerEffect[];
+}
+
+function cloneState(state: GoalReducerState): GoalReducerState {
+  return {
+    nextId: state.nextId,
+    goalsById: { ...state.goalsById },
+  };
+}
+
+function emptyProgress(): GoalProgressSnapshot {
+  return {
+    totalTasks: 0,
+    pendingTasks: 0,
+    inProgressTasks: 0,
+    completedTasks: 0,
+    activeLoops: 0,
+    pausedLoops: 0,
+    runningMonitors: 0,
+    completedMonitors: 0,
+    erroredMonitors: 0,
+    stoppedMonitors: 0,
+  };
+}
+
+function emptyVerification(): GoalVerificationState {
+  return {
+    attempts: 0,
+    passes: 0,
+    failures: 0,
+  };
+}
+
+function persist(goal: GoalEntry): GoalReducerEffect {
+  return {
+    type: "PERSIST_GOAL",
+    entityType: "goal",
+    entityId: goal.id,
+    payload: { goal },
+  };
+}
+
+function isTerminal(goal: GoalEntry): boolean {
+  return goal.status === "satisfied" || goal.status === "failed" || goal.status === "archived";
+}
+
+export function reduceGoalState(state: GoalReducerState, event: GoalReducerEvent): GoalReduceResult {
+  if (event.type === "GOAL_CREATED") {
+    const next = cloneState(state);
+    const id = String(next.nextId++);
+    const goal: GoalEntry = {
+      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: [] };
+
+  const next = cloneState(state);
+  const goal: GoalEntry = {
+    ...current,
+    progress: { ...current.progress },
+    verification: { ...current.verification },
+  };
+
+  let extraEffects: GoalReducerEffect[] = [];
+
+  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],
+  };
+}