@hank-warren/pi-loop 0.7.0 → 0.9.0

package/src/schedule/command.ts

@@ -1,255 +0,0 @@
-/**
- * Deterministic `/schedule` parsing. Grammar:
- *
- *   /schedule                                       manager TUI
- *   /schedule list
- *   /schedule every <dur>  [flags] <prompt...>
- *   /schedule at <ISO|+dur> [flags] <prompt...>
- *   /schedule cron "<m h dom mon dow>" [flags] <prompt...>
- *   /schedule pause|resume|delete|run|status <id>
- *
- * Flags: --run (headless instead of an in-session prompt), --cwd <path>,
- * --max <n|unlimited>, --wake always|failure|success|never, --name <text>.
- *
- * The extension owns this grammar, never the model — same reason `/loop`
- * does. A model that can schedule its own future turns can schedule its way
- * around every limit the loop imposes.
- */
-
-import { parseDuration } from "../interval.js";
-import { parseCron } from "./cron.js";
-import {
-	MIN_INTERVAL_MS,
-	type ScheduleSpec,
-	type TaskSpec,
-	WAKE_ON_VALUES,
-	type WakeOn,
-} from "./model.js";
-
-export const SCHEDULE_SUBCOMMANDS = [
-	"list",
-	"pause",
-	"resume",
-	"delete",
-	"run",
-	"status",
-] as const;
-export type ScheduleSubcommand = (typeof SCHEDULE_SUBCOMMANDS)[number];
-
-export interface ScheduleCreateCommand {
-	kind: "create";
-	name: string;
-	schedule: ScheduleSpec;
-	task: TaskSpec;
-	maxRuns?: number | null;
-	/** Set when a sub-minute interval was raised to the floor. */
-	clampedFrom?: number;
-}
-
-export type ScheduleCommand =
-	| { kind: "show" }
-	| { kind: "list" }
-	| { kind: ScheduleSubcommand; id: string }
-	| ScheduleCreateCommand
-	| { kind: "error"; message: string };
-
-export interface ParseScheduleOptions {
-	/** Default working directory for a headless run. */
-	cwd: string;
-	now?: number;
-}
-
-export function parseScheduleCommand(
-	args: string,
-	options: ParseScheduleOptions,
-): ScheduleCommand {
-	const trimmed = args.trim();
-	if (!trimmed) return { kind: "show" };
-	const tokens = [...args.matchAll(/\S+/g)].map((match) => ({
-		text: match[0],
-		index: match.index,
-	}));
-	const head = tokens[0]?.text ?? "";
-	if (head === "list") return { kind: "list" };
-	if ((SCHEDULE_SUBCOMMANDS as readonly string[]).includes(head)) {
-		const id = tokens[1]?.text;
-		if (!id) return { kind: "error", message: `/schedule ${head} needs a task id.` };
-		return { kind: head as ScheduleSubcommand, id };
-	}
-
-	const now = options.now ?? Date.now();
-	let position = 1;
-	let schedule: ScheduleSpec | undefined;
-	let clampedFrom: number | undefined;
-	if (head === "every") {
-		const value = tokens[1]?.text;
-		if (!value) return { kind: "error", message: "/schedule every needs a duration, e.g. 30m." };
-		const everyMs = parseDuration(value);
-		if (everyMs === undefined) {
-			return {
-				kind: "error",
-				message: `Invalid interval: ${value}. Use <number><unit> with unit s, m, h, or d.`,
-			};
-		}
-		if (everyMs < MIN_INTERVAL_MS) clampedFrom = everyMs;
-		schedule = { kind: "interval", everyMs: Math.max(MIN_INTERVAL_MS, everyMs) };
-		position = 2;
-	} else if (head === "at") {
-		const value = tokens[1]?.text;
-		if (!value) {
-			return {
-				kind: "error",
-				message: "/schedule at needs a time: an ISO timestamp, or +<duration> such as +90m.",
-			};
-		}
-		const at = parseAt(value, now);
-		if (at === undefined) {
-			return {
-				kind: "error",
-				message: `Invalid time: ${value}. Use an ISO timestamp (2026-01-31T09:00) or +<duration> such as +90m.`,
-			};
-		}
-		if (at <= now) return { kind: "error", message: `That time is in the past: ${value}.` };
-		schedule = { kind: "once", at };
-		position = 2;
-	} else if (head === "cron") {
-		const quoted = readQuoted(args, tokens[1]?.index ?? 0);
-		const expression = quoted?.value ?? tokens.slice(1, 6).map((token) => token.text).join(" ");
-		const parsed = parseCron(expression);
-		if (!parsed.ok) return { kind: "error", message: `Invalid cron expression: ${parsed.error}.` };
-		schedule = { kind: "cron", expression: parsed.spec.expression };
-		position = quoted ? tokenIndexAfter(tokens, quoted.end) : 6;
-	} else {
-		return {
-			kind: "error",
-			message: `Unknown /schedule form: ${head}. Use every <dur>, at <time>, cron "<expr>", list, pause, resume, run, status, or delete.`,
-		};
-	}
-
-	let headless = false;
-	let cwd = options.cwd;
-	let wakeOn: WakeOn = "failure";
-	let maxRuns: number | null | undefined;
-	let name: string | undefined;
-	while (position < tokens.length) {
-		const token = tokens[position];
-		if (token === undefined || !token.text.startsWith("--")) break;
-		const [flag, inline] = splitFlag(token.text);
-		const value = inline ?? tokens[position + 1]?.text;
-		if (flag === "--run") {
-			headless = true;
-			position += 1;
-			continue;
-		}
-		if (value === undefined) return { kind: "error", message: `${flag} needs a value.` };
-		if (flag === "--cwd") {
-			cwd = value;
-		} else if (flag === "--wake") {
-			if (!WAKE_ON_VALUES.includes(value as WakeOn)) {
-				return {
-					kind: "error",
-					message: `Invalid --wake value: ${value}. Use ${WAKE_ON_VALUES.join(", ")}.`,
-				};
-			}
-			wakeOn = value as WakeOn;
-		} else if (flag === "--max") {
-			if (value === "unlimited" || value === "null") maxRuns = null;
-			else {
-				const parsed = Number(value);
-				if (!Number.isSafeInteger(parsed) || parsed <= 0) {
-					return {
-						kind: "error",
-						message: `Invalid --max value: ${value}. Use a positive whole number or unlimited.`,
-					};
-				}
-				maxRuns = parsed;
-			}
-		} else if (flag === "--name") {
-			name = value;
-		} else {
-			return {
-				kind: "error",
-				message: `Unknown flag: ${flag}. Known flags: --run, --cwd, --max, --wake, --name.`,
-			};
-		}
-		position += inline === undefined ? 2 : 1;
-	}
-
-	const promptToken = tokens[position];
-	const prompt = promptToken === undefined ? "" : args.slice(promptToken.index).trim();
-	if (!prompt) {
-		return { kind: "error", message: "A scheduled task needs a prompt to run." };
-	}
-	return {
-		kind: "create",
-		name: name ?? summarize(prompt),
-		schedule,
-		task: headless ? { kind: "run", prompt, cwd, wakeOn } : { kind: "prompt", prompt },
-		...(maxRuns === undefined ? {} : { maxRuns }),
-		...(clampedFrom === undefined ? {} : { clampedFrom }),
-	};
-}
-
-function parseAt(value: string, now: number): number | undefined {
-	if (value.startsWith("+")) {
-		const delay = parseDuration(value.slice(1));
-		return delay === undefined ? undefined : now + delay;
-	}
-	const parsed = Date.parse(value);
-	return Number.isFinite(parsed) ? parsed : undefined;
-}
-
-/** Read a quoted string starting at `from`, or undefined when unquoted. */
-function readQuoted(args: string, from: number): { value: string; end: number } | undefined {
-	const quote = args[from];
-	if (quote !== '"' && quote !== "'") return undefined;
-	const end = args.indexOf(quote, from + 1);
-	if (end === -1) return undefined;
-	return { value: args.slice(from + 1, end), end };
-}
-
-function tokenIndexAfter(
-	tokens: ReadonlyArray<{ text: string; index: number }>,
-	offset: number,
-): number {
-	for (let index = 0; index < tokens.length; index += 1) {
-		const token = tokens[index];
-		if (token && token.index > offset) return index;
-	}
-	return tokens.length;
-}
-
-function splitFlag(token: string): [string, string | undefined] {
-	const equals = token.indexOf("=");
-	if (equals === -1) return [token, undefined];
-	return [token.slice(0, equals), token.slice(equals + 1)];
-}
-
-function summarize(prompt: string): string {
-	const collapsed = prompt.replace(/\s+/gu, " ").trim();
-	return collapsed.length <= 60 ? collapsed : `${collapsed.slice(0, 59)}…`;
-}
-
-export interface ScheduleArgumentCompletion {
-	value: string;
-	label: string;
-	description?: string;
-}
-
-const COMPLETIONS: readonly ScheduleArgumentCompletion[] = [
-	{ value: "every", label: "every", description: "Repeat on an interval, e.g. every 30m" },
-	{ value: "at", label: "at", description: "Fire once, e.g. at +90m or an ISO timestamp" },
-	{ value: "cron", label: "cron", description: 'Fire on a cron expression, e.g. cron "0 9 * * 1"' },
-	{ value: "list", label: "list", description: "List scheduled tasks" },
-	{ value: "pause", label: "pause", description: "Pause a task" },
-	{ value: "resume", label: "resume", description: "Resume a paused task" },
-	{ value: "run", label: "run", description: "Run a task now" },
-	{ value: "status", label: "status", description: "Show one task in detail" },
-	{ value: "delete", label: "delete", description: "Delete a task" },
-];
-
-export function completeScheduleArguments(prefix: string): ScheduleArgumentCompletion[] | null {
-	const trimmed = prefix.trimStart();
-	const matches = COMPLETIONS.filter((candidate) => candidate.value.startsWith(trimmed));
-	return matches.length > 0 ? matches : null;
-}

package/src/schedule/cron.ts

@@ -1,182 +0,0 @@
-/**
- * A five-field cron parser, minute granularity, stdlib only.
- *
- * Deliberately small and numeric: `minute hour day-of-month month
- * day-of-week`, each field `*`, a number, `a-b`, `a,b,c`, `*/n`, or
- * `a-b/n`. No names, no `@daily`, no seconds, no timezones beyond the host's
- * local time. Every one of those is a place where two implementations
- * disagree, and a scheduler whose semantics are debatable is worse than one
- * that refuses the expression.
- *
- * Day-of-month and day-of-week follow the traditional cron rule: when both
- * are restricted, a day matching *either* fires. That is genuinely surprising
- * behaviour, but it is what every crontab in the world means, and inventing a
- * more sensible rule here would be the bigger trap.
- */
-
-export interface CronSpec {
-	expression: string;
-	minutes: ReadonlySet<number>;
-	hours: ReadonlySet<number>;
-	daysOfMonth: ReadonlySet<number>;
-	months: ReadonlySet<number>;
-	daysOfWeek: ReadonlySet<number>;
-	/** Both day fields restricted: match either, per traditional cron. */
-	dayUnion: boolean;
-}
-
-interface FieldRange {
-	min: number;
-	max: number;
-}
-
-const FIELDS: ReadonlyArray<{ name: string; range: FieldRange }> = [
-	{ name: "minute", range: { min: 0, max: 59 } },
-	{ name: "hour", range: { min: 0, max: 23 } },
-	{ name: "day-of-month", range: { min: 1, max: 31 } },
-	{ name: "month", range: { min: 1, max: 12 } },
-	{ name: "day-of-week", range: { min: 0, max: 7 } },
-];
-
-export type CronParseResult =
-	| { ok: true; spec: CronSpec }
-	| { ok: false; error: string };
-
-export function parseCron(expression: string): CronParseResult {
-	const fields = expression.trim().split(/\s+/u);
-	if (fields.length !== 5) {
-		return {
-			ok: false,
-			error: `a cron expression has 5 fields (minute hour day-of-month month day-of-week), got ${fields.length}`,
-		};
-	}
-	const parsed: Array<Set<number>> = [];
-	for (let index = 0; index < FIELDS.length; index += 1) {
-		const field = FIELDS[index];
-		const text = fields[index];
-		if (!field || text === undefined) return { ok: false, error: "malformed cron expression" };
-		const values = parseField(text, field.range);
-		if (!values) return { ok: false, error: `invalid ${field.name} field: ${text}` };
-		parsed.push(values);
-	}
-	const [minutes, hours, daysOfMonth, months, rawDaysOfWeek] = parsed as [
-		Set<number>,
-		Set<number>,
-		Set<number>,
-		Set<number>,
-		Set<number>,
-	];
-	// 7 and 0 are both Sunday.
-	const daysOfWeek = new Set([...rawDaysOfWeek].map((day) => (day === 7 ? 0 : day)));
-	return {
-		ok: true,
-		spec: {
-			expression: fields.join(" "),
-			minutes,
-			hours,
-			daysOfMonth,
-			months,
-			daysOfWeek,
-			dayUnion: fields[2] !== "*" && fields[4] !== "*",
-		},
-	};
-}
-
-function parseField(text: string, range: FieldRange): Set<number> | undefined {
-	const values = new Set<number>();
-	for (const part of text.split(",")) {
-		const [spec, stepText] = part.split("/");
-		if (spec === undefined || spec === "") return undefined;
-		let step = 1;
-		if (stepText !== undefined) {
-			step = Number(stepText);
-			if (!Number.isSafeInteger(step) || step <= 0) return undefined;
-		}
-		let from: number;
-		let to: number;
-		if (spec === "*") {
-			from = range.min;
-			to = range.max;
-		} else if (spec.includes("-")) {
-			const [fromText, toText, ...rest] = spec.split("-");
-			if (rest.length > 0) return undefined;
-			from = Number(fromText);
-			to = Number(toText);
-		} else {
-			from = Number(spec);
-			to = from;
-		}
-		if (!Number.isSafeInteger(from) || !Number.isSafeInteger(to) || from > to) return undefined;
-		if (from < range.min || to > range.max) return undefined;
-		for (let value = from; value <= to; value += step) values.add(value);
-	}
-	return values.size > 0 ? values : undefined;
-}
-
-/** Whether a local-time date matches the spec, to the minute. */
-export function cronMatches(spec: CronSpec, date: Date): boolean {
-	if (!spec.minutes.has(date.getMinutes())) return false;
-	if (!spec.hours.has(date.getHours())) return false;
-	if (!spec.months.has(date.getMonth() + 1)) return false;
-	const domMatch = spec.daysOfMonth.has(date.getDate());
-	const dowMatch = spec.daysOfWeek.has(date.getDay());
-	return spec.dayUnion ? domMatch || dowMatch : domMatch && dowMatch;
-}
-
-/** How far ahead a next-fire search gives up, in days. */
-const SEARCH_LIMIT_DAYS = 5 * 366;
-
-/**
- * The next local-time minute at or after `after` that matches, or undefined
- * when the expression can never fire again (30 February and friends).
- *
- * Scans day by day and only walks minutes inside a matching day, so an
- * expression that fires once a year costs a few thousand cheap comparisons
- * rather than half a million.
- */
-export function nextCronFire(spec: CronSpec, after: number): number | undefined {
-	const cursor = new Date(after);
-	cursor.setSeconds(0, 0);
-	cursor.setMinutes(cursor.getMinutes() + 1);
-	for (let day = 0; day <= SEARCH_LIMIT_DAYS; day += 1) {
-		if (dayCouldMatch(spec, cursor)) {
-			const hit = firstMatchingMinuteOfDay(spec, cursor, day === 0);
-			if (hit !== undefined) return hit;
-		}
-		cursor.setDate(cursor.getDate() + 1);
-		cursor.setHours(0, 0, 0, 0);
-	}
-	return undefined;
-}
-
-function dayCouldMatch(spec: CronSpec, date: Date): boolean {
-	if (!spec.months.has(date.getMonth() + 1)) return false;
-	const domMatch = spec.daysOfMonth.has(date.getDate());
-	const dowMatch = spec.daysOfWeek.has(date.getDay());
-	return spec.dayUnion ? domMatch || dowMatch : domMatch && dowMatch;
-}
-
-function firstMatchingMinuteOfDay(
-	spec: CronSpec,
-	dayStart: Date,
-	respectCursorTime: boolean,
-): number | undefined {
-	const startHour = respectCursorTime ? dayStart.getHours() : 0;
-	const startMinute = respectCursorTime ? dayStart.getMinutes() : 0;
-	for (const hour of sorted(spec.hours)) {
-		if (hour < startHour) continue;
-		for (const minute of sorted(spec.minutes)) {
-			if (hour === startHour && minute < startMinute) continue;
-			const candidate = new Date(dayStart);
-			candidate.setHours(hour, minute, 0, 0);
-			// A DST jump can move the wall clock off the requested slot; the
-			// match check is authoritative.
-			if (cronMatches(spec, candidate)) return candidate.getTime();
-		}
-	}
-	return undefined;
-}
-
-function sorted(values: ReadonlySet<number>): number[] {
-	return [...values].sort((a, b) => a - b);
-}

package/src/schedule/manager.ts

@@ -1,129 +0,0 @@
-/**
- * The `/schedule` manager, in the same shape as the `/loop` manager: Pi's
- * native dialog primitives, and a plain notification in non-TUI modes so
- * every action is reachable without a menu.
- */
-
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { describeSchedule, nextFireAt, type ScheduledTask } from "./model.js";
-import type { Scheduler } from "./runner.js";
-
-export async function showScheduleManager(
-	scheduler: Scheduler,
-	ctx: ExtensionCommandContext,
-): Promise<void> {
-	if (ctx.mode !== "tui") {
-		ctx.ui.notify(listTasks(scheduler).join("\n"), "info");
-		return;
-	}
-	for (;;) {
-		const tasks = scheduler.tasks();
-		if (tasks.length === 0) {
-			ctx.ui.notify(
-				'No scheduled tasks. Create one with /schedule every 30m <prompt>, /schedule at +2h <prompt>, or /schedule cron "0 9 * * 1" <prompt>.',
-				"info",
-			);
-			return;
-		}
-		const rows = tasks.map((task) => summarizeRow(task));
-		const choice = await ctx.ui.select("Scheduled tasks", rows);
-		if (choice === undefined) return;
-		const task = tasks[rows.indexOf(choice)];
-		if (!task) return;
-		if (!(await manageTask(scheduler, ctx, task))) return;
-	}
-}
-
-/** Returns false when the manager should close. */
-async function manageTask(
-	scheduler: Scheduler,
-	ctx: ExtensionCommandContext,
-	task: ScheduledTask,
-): Promise<boolean> {
-	const actions = [
-		"Details",
-		task.status === "paused" ? "Resume" : "Pause",
-		"Run now",
-		"Delete",
-		"Back",
-	];
-	const action = await ctx.ui.select(`${task.name} · ${task.status}`, actions);
-	if (action === undefined || action === "Back") return true;
-	switch (action) {
-		case "Details":
-			ctx.ui.notify(describeTask(task).join("\n"), "info");
-			return true;
-		case "Pause":
-			scheduler.update({ ...task, status: "paused" });
-			ctx.ui.notify(`Paused "${task.name}".`, "info");
-			return true;
-		case "Resume":
-			scheduler.update({ ...task, status: "active" });
-			ctx.ui.notify(`Resumed "${task.name}".`, "info");
-			return true;
-		case "Run now":
-			scheduler.fireNow(task);
-			ctx.ui.notify(`Running "${task.name}" now.`, "info");
-			return true;
-		case "Delete": {
-			const confirmed = await ctx.ui.confirm("Delete task?", `Delete "${task.name}"?`);
-			if (!confirmed) return true;
-			scheduler.remove(task.id);
-			ctx.ui.notify(`Deleted "${task.name}".`, "info");
-			return true;
-		}
-		default:
-			return true;
-	}
-}
-
-export function listTasks(scheduler: Scheduler): string[] {
-	const tasks = scheduler.tasks();
-	if (tasks.length === 0) {
-		return [
-			"No scheduled tasks.",
-			'Create one with /schedule every 30m <prompt>, /schedule at +2h <prompt>, or /schedule cron "0 9 * * 1" <prompt>.',
-		];
-	}
-	return tasks.map((task) => summarizeRow(task));
-}
-
-function summarizeRow(task: ScheduledTask): string {
-	const next = nextFireAt(task, Date.now());
-	// A finished or paused task has no "next" to report; saying "next done"
-	// reads as though something were still scheduled.
-	const when =
-		task.status !== "active"
-			? task.status
-			: next === undefined
-				? "never again"
-				: `next ${new Date(next).toLocaleString()}`;
-	const result = task.lastResult ? ` · last ${task.lastResult.ok ? "ok" : "failed"}` : "";
-	return `${task.id} · ${task.task.kind} · ${describeSchedule(task.schedule)} · ${when}${result} · ${task.name}`;
-}
-
-export function describeTask(task: ScheduledTask): string[] {
-	const next = nextFireAt(task, Date.now());
-	const lines = [
-		`Task: ${task.name}`,
-		`Id: ${task.id}`,
-		`Kind: ${task.task.kind === "run" ? "headless run" : "in-session prompt"}`,
-		`Schedule: ${describeSchedule(task.schedule)}`,
-		`Status: ${task.status}`,
-		`Runs: ${task.runs}${task.maxRuns === null ? " (unlimited)" : ` of ${task.maxRuns}`}`,
-		`Next fire: ${next === undefined ? "never again" : new Date(next).toLocaleString()}`,
-		`Expires: ${new Date(task.expiresAt).toLocaleString()}`,
-	];
-	if (task.task.kind === "run") {
-		lines.push(`Working directory: ${task.task.cwd}`, `Wake the session: ${task.task.wakeOn}`);
-	}
-	if (task.lastResult) {
-		lines.push(
-			`Last result: ${task.lastResult.ok ? "ok" : "failed"} at ${new Date(task.lastResult.at).toLocaleString()}${
-				task.lastResult.detail ? ` — ${task.lastResult.detail}` : ""
-			}`,
-		);
-	}
-	lines.push(`Prompt: ${task.task.prompt}`);
-	return lines;
-}