@trevonistrevon/pi-loop 0.4.11 → 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/coordinator.ts

@@ -0,0 +1,115 @@
+export type ReducerSource =
+  | "tool"
+  | "command"
+  | "scheduler"
+  | "eventbus"
+  | "monitor"
+  | "session"
+  | "coordinator"
+  | "system";
+
+export type ReducerEntityType = "task" | "loop" | "monitor" | "notification" | "goal";
+
+export interface ReducerEvent<TType extends string = string, TPayload = unknown> {
+  type: TType;
+  at: number;
+  source: ReducerSource;
+  entityType?: ReducerEntityType;
+  entityId?: string;
+  payload: TPayload;
+}
+
+export interface ReducerEffect<TEffect extends string = string, TPayload = unknown> {
+  type: TEffect;
+  entityType?: ReducerEntityType;
+  entityId?: string;
+  payload: TPayload;
+}
+
+export type DispatchEventEffect = ReducerEffect<"DISPATCH_EVENT", { event: ReducerEvent }>;
+export type AnyReducerEffect = ReducerEffect | DispatchEventEffect;
+
+export type ReducerHandler =
+  (event: ReducerEvent) => undefined | AnyReducerEffect[] | Promise<undefined | AnyReducerEffect[]>;
+
+export type EffectHandler =
+  (effect: ReducerEffect) => void | Promise<void>;
+
+export interface CoordinatorOptions {
+  reducers: ReducerHandler[];
+  effectHandlers?: Partial<Record<string, EffectHandler>>;
+  effectExecutor?: EffectHandler;
+  maxDispatchDepth?: number;
+}
+
+export class CoordinatorError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "CoordinatorError";
+  }
+}
+
+export interface Coordinator {
+  dispatch(event: ReducerEvent): Promise<void>;
+}
+
+export function createCoordinator(options: CoordinatorOptions): Coordinator {
+  const {
+    reducers,
+    effectHandlers = {},
+    effectExecutor,
+    maxDispatchDepth = 100,
+  } = options;
+
+  function isPromiseLike<T>(value: T | Promise<T>): value is Promise<T> {
+    return typeof value === "object" && value !== null && "then" in value;
+  }
+
+  async function executeEffect(effect: AnyReducerEffect, depth: number): Promise<void> {
+    if (effect.type === "DISPATCH_EVENT") {
+      const dispatchEffect = effect as DispatchEventEffect;
+      const derivedEvent = dispatchEffect.payload.event;
+      if (!derivedEvent) {
+        throw new CoordinatorError("DISPATCH_EVENT effect missing payload.event");
+      }
+      await dispatchAtDepth(derivedEvent, depth + 1);
+      return;
+    }
+
+    const specificHandler = effectHandlers[effect.type];
+    if (specificHandler) {
+      const handled = specificHandler(effect);
+      if (isPromiseLike(handled)) await handled;
+      return;
+    }
+
+    if (effectExecutor) {
+      const handled = effectExecutor(effect);
+      if (isPromiseLike(handled)) await handled;
+    }
+  }
+
+  async function dispatchAtDepth(event: ReducerEvent, depth: number): Promise<void> {
+    if (depth > maxDispatchDepth) {
+      throw new CoordinatorError(`Maximum dispatch depth exceeded (${maxDispatchDepth})`);
+    }
+
+    const effects: AnyReducerEffect[] = [];
+    for (const reducer of reducers) {
+      const emitted = reducer(event);
+      const resolved = isPromiseLike(emitted) ? await emitted : emitted;
+      if (!resolved || resolved.length === 0) continue;
+      effects.push(...resolved);
+    }
+
+    for (const effect of effects) {
+      await executeEffect(effect, depth);
+    }
+  }
+
+  return {
+    async dispatch(event: ReducerEvent): Promise<void> {
+      await dispatchAtDepth(event, 1);
+    },
+  };
+}

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(),
+    });
+  };
+}