@agimon-ai/doompi-loop 0.0.1-alpha.84 → 0.0.1-alpha.86

package/dist/extensions/pi.mjs

@@ -1,20 +1,13 @@
 import { t as DOOM_LOOP_LAUNCHERS_SERVICE } from "../loopLaunchers-cCniFbVA.mjs";
-import { a as LIST_COMMAND_NAME, i as LIST_COMMAND_DESCRIPTION, n as formatLoopStatusView, o as START_COMMAND_DESCRIPTION, r as createDoomLoopLaunchersService, s as START_COMMAND_NAME, t as LOOP_VIEW_STATUS_KEY } from "../loopView-CmuIEbUa.mjs";
-import { definePiExtension } from "@agimon-ai/doompi-core/piExtension";
-import { composeRootHooks, defineCliCommand, defineCliHook, defineResource, defineRoot } from "@agimon-ai/doompi-core/extensionFile";
+import { _ as PACKAGE_SOURCE, a as CronLoopSchema, c as parseIntervalLoop, d as START_COMMAND_DESCRIPTION, f as START_COMMAND_NAME, g as NOTIFY_WARNING_LEVEL, h as NOTIFY_INFO_LEVEL, i as createDoomLoopLaunchersService, l as LIST_COMMAND_DESCRIPTION, m as MODE_STATUS_ID, n as formatLoopStatusView, o as IntervalLoopSchema, p as ACTIVE_MODE_COLOR, r as createLoopTools, s as parseCronLoop, t as LOOP_VIEW_STATUS_KEY, u as LIST_COMMAND_NAME, v as STATUS_KEY } from "../loopView-BK4X_1UI.mjs";
+import { definePiExtension, piToolContributions } from "@agimon-ai/doompi-core/piExtension";
+import { composeRootHooks, defineCliCommand, defineCliHook, defineResource, defineRoot, defineTool as defineTool$1, defineToolRestriction } from "@agimon-ai/doompi-core/extensionFile";
 import { defineMinorMode, piMinorModes } from "@agimon-ai/doompi-minor-mode";
 import { DOOM_CORDIS_SESSION_SERVICE } from "@agimon-ai/doompi-core/cordisHost";
 import { DOOM_UI_HUB_SERVICE, requireDoomUiHub } from "@agimon-ai/doompi-core/uiHub";
+import { Cron } from "croner";
 import { DOOM_FULLSCREEN_UI_OPTIONS, DOOM_NAVIGATION_KEYS, DOOM_OVERLAY_ACCENT, DoomOverlay } from "@agimon-ai/doompi-ui/doomOverlay";
 import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
-//#region src/constants/piLoop.ts
-const PACKAGE_SOURCE = "@agimon-ai/doompi-loop";
-const STATUS_KEY = "doom-loop";
-const MODE_STATUS_ID = "loop.active";
-const ACTIVE_MODE_COLOR = "warning";
-const NOTIFY_INFO_LEVEL = "info";
-const NOTIFY_WARNING_LEVEL = "warning";
-//#endregion
 //#region src/services/loopCommand/index.ts
 function createLoopCommands(handlers) {
 	return [[START_COMMAND_NAME, {
@@ -22,37 +15,43 @@ function createLoopCommands(handlers) {
 		handler: async (args, ctx) => handlers.start(ctx, args)
 	}], [LIST_COMMAND_NAME, {
 		description: LIST_COMMAND_DESCRIPTION,
-		handler: async (_args, ctx) => handlers.list(ctx)
+		handler: async (args, ctx) => handlers.list(ctx, args)
 	}]];
 }
 //#endregion
 //#region src/services/defaultLoopLauncher/index.ts
-const DEFAULT_LAUNCHER_ID = "doompi.default";
 const DEFAULT_INTERVAL_SECONDS = 300;
 const MIN_INTERVAL_SECONDS = 30;
 const MAX_INTERVAL_SECONDS = 3600;
 const MILLISECONDS_PER_SECOND = 1e3;
 const PROMPT_PREVIEW_LENGTH = 80;
-function intervalError(raw) {
-	const seconds = Number(raw);
-	if (!Number.isInteger(seconds)) return `Interval must be a whole number of seconds, got ${raw}.`;
-	if (seconds < MIN_INTERVAL_SECONDS || seconds > MAX_INTERVAL_SECONDS) return `Interval must be between ${MIN_INTERVAL_SECONDS} and ${MAX_INTERVAL_SECONDS} seconds.`;
-}
-async function prepareDefaultLoop(ui, signal) {
+async function prepareLoop(ui, request, cron) {
+	if (request.input !== void 0) return cron ? parseCronLoop(request.input) : parseIntervalLoop(request.input);
+	if (request.interactive === false) throw new Error("Loop configuration is required for agent launches.");
 	const prompt = (await ui.editor("Loop prompt", ""))?.trim();
-	if (!prompt || signal.aborted) return void 0;
-	const rawInterval = await ui.input("Loop interval in seconds", `Default: ${DEFAULT_INTERVAL_SECONDS}s`);
-	if (rawInterval === void 0 || signal.aborted) return void 0;
-	const normalizedInterval = rawInterval.trim() || String(DEFAULT_INTERVAL_SECONDS);
-	const error = intervalError(normalizedInterval);
-	if (error) {
-		ui.notify(error, NOTIFY_WARNING_LEVEL);
+	if (!prompt || request.signal.aborted) return void 0;
+	if (cron) {
+		const expression = await ui.input("Cron expression (five fields)", "0 * * * *");
+		if (expression === void 0 || request.signal.aborted) return void 0;
+		const timezone = await ui.input("Loop timezone", "UTC");
+		if (timezone === void 0 || request.signal.aborted) return void 0;
+		return parseCronLoop({
+			prompt,
+			cron: expression,
+			timezone: timezone.trim() || "UTC"
+		});
+	}
+	const raw = await ui.input("Loop interval in seconds", `Default: ${DEFAULT_INTERVAL_SECONDS}s`);
+	if (raw === void 0 || request.signal.aborted) return void 0;
+	const intervalSeconds = Number(raw.trim() || DEFAULT_INTERVAL_SECONDS);
+	if (!Number.isInteger(intervalSeconds) || intervalSeconds < MIN_INTERVAL_SECONDS || intervalSeconds > MAX_INTERVAL_SECONDS) {
+		ui.notify(`Interval must be between ${MIN_INTERVAL_SECONDS} and ${MAX_INTERVAL_SECONDS} seconds.`, NOTIFY_WARNING_LEVEL);
 		return;
 	}
-	return {
+	return parseIntervalLoop({
 		prompt,
-		intervalSeconds: Number(normalizedInterval)
-	};
+		intervalSeconds
+	});
 }
 function promptPreview(prompt) {
 	const oneLine = prompt.replaceAll(/\s+/gu, " ").trim();
@@ -73,44 +72,62 @@ function createDefaultLoopLauncher(pi) {
 			loop.context.ui.notify(`Default loop pass could not start: ${error instanceof Error ? error.message : String(error)}`, NOTIFY_WARNING_LEVEL);
 		}
 	};
-	const onAgentSettled = () => {
-		const next = pending.values().next().value;
-		if (next) requestPass(next);
-	};
-	return {
-		onAgentSettled,
-		register(ctx, launchers) {
-			return launchers.register({
-				id: DEFAULT_LAUNCHER_ID,
-				source: PACKAGE_SOURCE,
-				label: "Default loop",
-				description: "Run your own prompt in this session on an interval",
-				async launch({ instanceId, signal }) {
-					const prepared = await prepareDefaultLoop(ctx.ui, signal);
-					if (!prepared || signal.aborted) return void 0;
-					const loop = {
-						...prepared,
-						context: ctx,
-						stopped: false
-					};
-					loop.timer = setInterval(() => requestPass(loop), loop.intervalSeconds * MILLISECONDS_PER_SECOND);
-					loop.timer.unref?.();
-					requestPass(loop);
-					return {
-						instanceId,
-						label: "Default loop",
-						detail: `every ${loop.intervalSeconds}s · ${promptPreview(loop.prompt)}`,
-						stop() {
-							if (loop.stopped) return;
-							loop.stopped = true;
-							if (loop.timer) clearInterval(loop.timer);
-							loop.timer = void 0;
-							pending.delete(loop);
-						}
-					};
+	const register = (ctx, launchers, cron) => launchers.register({
+		id: cron ? "doompi.cron" : "doompi.default",
+		source: PACKAGE_SOURCE,
+		label: cron ? "Cron loop" : "Default loop",
+		description: cron ? "Run a prompt on a five-field cron schedule." : "Run your own prompt in this session on an interval",
+		inputSchema: { ...cron ? CronLoopSchema : IntervalLoopSchema },
+		async launch(request) {
+			const prepared = await prepareLoop(ctx.ui, request, cron);
+			if (!prepared || request.signal.aborted) return void 0;
+			const loop = {
+				prompt: prepared.prompt,
+				context: ctx,
+				stopped: false
+			};
+			let stopTimer;
+			let schedule;
+			if ("cron" in prepared) {
+				const job = new Cron(prepared.cron, {
+					timezone: prepared.timezone,
+					unref: true
+				}, () => requestPass(loop));
+				if (job.nextRun() === null) {
+					job.stop();
+					throw new Error("Cron expression has no future run.");
 				}
-			});
+				stopTimer = () => {
+					job.stop();
+				};
+				schedule = `${prepared.cron} (${prepared.timezone})`;
+			} else {
+				const timer = setInterval(() => requestPass(loop), prepared.intervalSeconds * MILLISECONDS_PER_SECOND);
+				timer.unref?.();
+				stopTimer = () => clearInterval(timer);
+				schedule = `every ${prepared.intervalSeconds}s`;
+				requestPass(loop);
+			}
+			return {
+				instanceId: request.instanceId,
+				label: cron ? "Cron loop" : "Default loop",
+				detail: `${schedule} · ${promptPreview(loop.prompt)}`,
+				stop() {
+					if (loop.stopped) return;
+					loop.stopped = true;
+					stopTimer();
+					pending.delete(loop);
+				}
+			};
 		}
+	});
+	return {
+		onAgentSettled() {
+			const next = pending.values().next().value;
+			if (next) requestPass(next);
+		},
+		register: (ctx, launchers) => register(ctx, launchers, false),
+		registerCron: (ctx, launchers) => register(ctx, launchers, true)
 	};
 }
 //#endregion
@@ -306,34 +323,27 @@ async function openStartLoopOverlay(ctx, launchers) {
 }
 //#endregion
 //#region src/tui/loopRuntime.ts
-const MODE_ACTION_START = "start";
-const MODE_ACTION_STOP = "stop";
+const MODE_ACTION_ACTIVATE = "activate";
+const MODE_ACTION_DEACTIVATE = "deactivate";
 const SESSION_REPLACED_REASON = "Pi session replaced.";
 const SESSION_SHUTDOWN_REASON = "Pi session shut down.";
-function loopModeState(launchers, instances) {
-	const active = instances.length > 0;
+function loopModeState(enabled, instances) {
 	return {
-		activation: active ? "active" : "inactive",
-		condition: instances.some(({ state }) => state === "starting" || state === "stopping") ? "queued" : "ready",
-		...active ? {
-			detail: `${instances.length} active`,
+		activation: enabled ? "active" : "inactive",
+		condition: "ready",
+		...enabled ? {
+			detail: `${instances.length} loops`,
 			color: ACTIVE_MODE_COLOR
 		} : {},
-		actions: [...launchers.length > 0 ? [{
-			id: MODE_ACTION_START,
-			enabled: true
-		}] : [{
-			id: MODE_ACTION_START,
-			enabled: false,
-			disabledReason: "No loop launchers are registered."
-		}], ...active ? [{
-			id: MODE_ACTION_STOP,
-			enabled: true
-		}] : [{
-			id: MODE_ACTION_STOP,
-			enabled: false,
-			disabledReason: "No loops are active."
-		}]]
+		actions: [{
+			id: MODE_ACTION_ACTIVATE,
+			enabled: !enabled,
+			...enabled ? { disabledReason: "Loop mode is already active." } : {}
+		}, {
+			id: MODE_ACTION_DEACTIVATE,
+			enabled,
+			...enabled ? {} : { disabledReason: "Loop mode is not active." }
+		}]
 	};
 }
 /** Install Loop state and external resources into its host-owned Cordis plugin fiber. */
@@ -343,6 +353,15 @@ function createLoopPiRuntime(pi) {
 	let mode;
 	let disposeLeader;
 	const launchesInProgress = /* @__PURE__ */ new WeakSet();
+	let modeEnabled = false;
+	const toolListeners = /* @__PURE__ */ new Set();
+	const loopTools = createLoopTools(() => {
+		if (!activeSession) throw new Error("Loop launchers are unavailable for the active session.");
+		return activeSession.launchers;
+	}, () => {
+		if (!active || !modeEnabled) throw new Error("Enable Loop minor mode before using agent loop tools.");
+	});
+	const toolNames = new Set(loopTools.map((tool) => tool.name));
 	const currentSession = (context) => {
 		const binding = activeSession;
 		if (!active || !binding || binding.context.sessionManager !== context.sessionManager || binding.hostSession.sessionId !== context.sessionManager.getSessionId()) return;
@@ -365,66 +384,47 @@ function createLoopPiRuntime(pi) {
 			source: PACKAGE_SOURCE,
 			id: MODE_STATUS_ID,
 			label: "Loop",
-			description: "Session-scoped recurring prompt loops.",
+			description: "Give the agent tools to create, inspect, and stop session loops.",
 			order: 60,
 			actions: [{
-				id: MODE_ACTION_START,
-				label: "Start",
-				description: "Start a loop with a registered launcher.",
+				id: MODE_ACTION_ACTIVATE,
+				label: "Activate",
+				description: "Expose loop tools to the agent.",
 				contexts: ["tui", "headless"],
-				parameters: [{
-					name: "launcherId",
-					label: "Launcher",
-					kind: "string",
-					required: true,
-					minLength: 1
-				}, {
-					name: "instanceId",
-					label: "Instance ID",
-					kind: "string",
-					required: false,
-					minLength: 1
-				}]
+				parameters: []
 			}, {
-				id: MODE_ACTION_STOP,
-				label: "Stop",
-				description: "Stop one active loop instance.",
+				id: MODE_ACTION_DEACTIVATE,
+				label: "Deactivate",
+				description: "Hide agent loop tools. Existing loops and manual controls remain available.",
 				contexts: ["tui", "headless"],
-				parameters: [{
-					name: "instanceId",
-					label: "Instance ID",
-					kind: "string",
-					required: true,
-					minLength: 1
-				}, {
-					name: "reason",
-					label: "Reason",
-					kind: "string",
-					required: false,
-					minLength: 1
-				}]
+				parameters: []
 			}]
 		},
-		state: () => activeSession ? loopModeState(activeSession.launchers.listLaunchers(), activeSession.launchers.listInstances()) : loopModeState([], []),
-		async handleAction(_runtime, actionId, argumentsValue, { signal }) {
+		state: () => loopModeState(modeEnabled, activeSession?.launchers.listInstances() ?? []),
+		async handleAction(_runtime, actionId, _arguments, { signal }) {
 			signal.throwIfAborted();
 			const binding = activeSession ? currentSession(activeSession.context) : void 0;
 			if (!binding) throw new Error("Loop launchers are unavailable for the active session.");
-			if (actionId === MODE_ACTION_START) {
-				const instance = await binding.launchers.launch(argumentsValue.launcherId, argumentsValue.instanceId ? { instanceId: argumentsValue.instanceId } : {});
-				if (activeSession !== binding) throw new Error("Loop action became stale.");
-				return { message: instance ? `Loop '${instance.instanceId}' started.` : "Loop launch was cancelled." };
-			}
-			if (actionId === MODE_ACTION_STOP) {
-				const stopped = await binding.launchers.stop(argumentsValue.instanceId, argumentsValue.reason ?? "Stopped through minor_mode.");
-				if (activeSession !== binding) throw new Error("Loop action became stale.");
-				return { message: stopped ? "Loop stopped." : "Loop instance was not active." };
-			}
-			throw new Error(`Unknown loop mode action: ${actionId}`);
+			if (actionId !== MODE_ACTION_ACTIVATE && actionId !== MODE_ACTION_DEACTIVATE) throw new Error(`Unknown loop mode action: ${actionId}`);
+			modeEnabled = actionId === MODE_ACTION_ACTIVATE;
+			for (const listener of toolListeners) listener();
+			publishStatus(binding);
+			return { message: modeEnabled ? "Loop tools activated." : "Loop tools deactivated. Existing loops are unchanged." };
 		}
 	}).createOwner(void 0);
 	return {
 		onAgentSettled: defaultLauncher.onAgentSettled,
+		loopTools,
+		toolRestrictions: [{
+			source: PACKAGE_SOURCE,
+			restrict: (incoming) => modeEnabled ? incoming : incoming.filter((name) => !toolNames.has(name)),
+			subscribe(listener) {
+				toolListeners.add(listener);
+				return () => {
+					toolListeners.delete(listener);
+				};
+			}
+		}],
 		services: [(cordis) => {
 			cordis.inject([DOOM_UI_HUB_SERVICE], (uiContext) => {
 				const dispose = registerLeaderContribution(requireDoomUiHub(uiContext));
@@ -447,13 +447,17 @@ function createLoopPiRuntime(pi) {
 					launchers
 				};
 				activeSession = binding;
+				modeEnabled = false;
+				for (const listener of toolListeners) listener();
 				const provider = cordis.plugin((providerContext) => {
 					providerContext.provide(DOOM_LOOP_LAUNCHERS_SERVICE, launchers);
 				});
 				let defaultRegistration;
+				let cronRegistration;
 				let unsubscribe;
 				try {
 					defaultRegistration = defaultLauncher.register(hostSession.context, launchers);
+					cronRegistration = defaultLauncher.registerCron(hostSession.context, launchers);
 					unsubscribe = launchers.subscribe(() => publishStatus(binding));
 					publishStatus(binding);
 				} catch (error) {
@@ -464,12 +468,14 @@ function createLoopPiRuntime(pi) {
 				}
 				return async () => {
 					if (activeSession === binding) activeSession = void 0;
+					modeEnabled = false;
+					for (const listener of toolListeners) listener();
 					unsubscribe();
 					clearStatuses(binding);
 					mode?.publish();
 					const cleanupErrors = [];
 					try {
-						await defaultRegistration.dispose(SESSION_REPLACED_REASON);
+						await Promise.all([defaultRegistration.dispose(SESSION_REPLACED_REASON), cronRegistration.dispose(SESSION_REPLACED_REASON)]);
 					} catch (error) {
 						cleanupErrors.push(error);
 					}
@@ -528,9 +534,15 @@ function createLoopPiRuntime(pi) {
 					launchesInProgress.delete(binding);
 				}
 			},
-			async list(ctx) {
+			async list(ctx, args = "") {
 				const binding = currentSession(ctx);
 				if (!binding) return;
+				if (args.trim().startsWith("stop ")) {
+					const stopped = await binding.launchers.stop(args.trim().slice(5).trim(), "Stopped manually.");
+					ctx.ui.notify(stopped ? "Loop stopped." : "Loop instance was not active.", NOTIFY_INFO_LEVEL);
+					return;
+				}
+				if (args.trim()) throw new Error("Usage: /loops [stop instanceId]");
 				await openLoopListOverlay(ctx, binding.launchers);
 			}
 		},
@@ -539,6 +551,9 @@ function createLoopPiRuntime(pi) {
 			active = false;
 			const binding = activeSession;
 			activeSession = void 0;
+			modeEnabled = false;
+			for (const listener of toolListeners) listener();
+			toolListeners.clear();
 			if (binding) clearStatuses(binding);
 			mode?.publish();
 			disposeLeader?.();
@@ -552,6 +567,8 @@ var runtime_cli_default = (({ pi }) => {
 	const runtime = createLoopPiRuntime(pi);
 	return {
 		services: [...runtime.services ?? [], piMinorModes(runtime.minorModes)],
+		loopTools: runtime.loopTools,
+		toolRestrictions: runtime.toolRestrictions,
 		events: { agent_settled: runtime.onAgentSettled },
 		commands: createLoopCommands(runtime.handlers),
 		onDispose: () => runtime.onDispose(),
@@ -577,7 +594,7 @@ var root_cli_default = defineRoot((context) => {
 });
 //#endregion
 //#region src/extensions/workspaces/sessions/(backend)/command/loop.cli.ts
-var loop_cli_default = defineCliCommand((context) => context.root.commands[0]);
+var loop_cli_default$1 = defineCliCommand((context) => context.root.commands[0]);
 //#endregion
 //#region src/extensions/workspaces/sessions/(backend)/command/loops.cli.ts
 var loops_cli_default = defineCliCommand((context) => context.root.commands[1]);
@@ -588,8 +605,24 @@ var agent_settled_cli_default = defineCliHook((context) => context.root.events["
 //#region src/extensions/workspaces/sessions/(backend)/resource/doompi-use-loop.cli.ts
 var doompi_use_loop_cli_default = defineResource((context) => context.root.resources[0]);
 //#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool-restriction/loop.cli.ts
+var loop_cli_default = defineToolRestriction((context) => context.root.toolRestrictions[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/loop-list.cli.ts
+var loop_list_cli_default = defineTool$1((context) => context.root.loopTools[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/loop-start.cli.ts
+var loop_start_cli_default = defineTool$1((context) => context.root.loopTools[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/loop-stop.cli.ts
+var loop_stop_cli_default = defineTool$1((context) => context.root.loopTools[2]);
+//#endregion
 //#region generated/pi.ts
 const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
 const extension = definePiExtension("@agimon-ai/doompi-loop", async (context) => {
 	const scopeSession = await root_cli_default(context);
 	const contextSession = {
@@ -599,12 +632,20 @@ const extension = definePiExtension("@agimon-ai/doompi-loop", async (context) =>
 	return {
 		...composeRootHooks(scopeSession),
 		get commands() {
-			return [at(loop_cli_default, contextSession), at(loops_cli_default, contextSession)];
+			return [at(loop_cli_default$1, contextSession), at(loops_cli_default, contextSession)];
 		},
 		events: { agent_settled: at(agent_settled_cli_default, contextSession) },
 		get resources() {
 			return [at(doompi_use_loop_cli_default, contextSession)];
 		},
+		get toolRestrictions() {
+			return [at(loop_cli_default, contextSession)];
+		},
+		...piToolContributions("@agimon-ai/doompi-loop", [
+			via({ name: "loop_list" }, at(loop_list_cli_default, contextSession)),
+			via({ name: "loop_start" }, at(loop_start_cli_default, contextSession)),
+			via({ name: "loop_stop" }, at(loop_stop_cli_default, contextSession))
+		]),
 		services: [...scopeSession.services ?? []]
 	};
 });