@agimon-ai/doompi-loop 0.0.1-alpha.83 → 0.0.1-alpha.85

package/dist/extensions/server.mjs

@@ -1,214 +1,204 @@
-import { a as LIST_COMMAND_NAME, n as formatLoopStatusView, r as createDoomLoopLaunchersService, s as START_COMMAND_NAME, t as LOOP_VIEW_STATUS_KEY } from "../loopView-CmuIEbUa.mjs";
-import { composeRootHooks, defineRoot, defineRoutedContribution } from "@agimon-ai/doompi-core/extensionFile";
+import { t as DOOM_LOOP_LAUNCHERS_SERVICE } from "../loopLaunchers-cCniFbVA.mjs";
+import { _ as PACKAGE_SOURCE, a as CronLoopSchema, c as parseIntervalLoop, f as START_COMMAND_NAME, i as createDoomLoopLaunchersService, m as MODE_STATUS_ID, n as formatLoopStatusView, o as IntervalLoopSchema, r as createLoopTools, s as parseCronLoop, t as LOOP_VIEW_STATUS_KEY, u as LIST_COMMAND_NAME } from "../loopView-BK4X_1UI.mjs";
+import { composeRootHooks, defineRoot, defineRoutedContribution, defineTool } from "@agimon-ai/doompi-core/extensionFile";
 import { defineMinorMode, serverMinorModes } from "@agimon-ai/doompi-minor-mode";
+import { Cron } from "croner";
 import { defineServerPlugin, readPackageResource } from "@agimon-ai/doompi-core/serverFacet";
 //#region src/services/serverRuntime/index.ts
-const SOURCE = "@agimon-ai/doompi-loop";
-const MODE_ID = "loop.active";
-const DEFAULT_LAUNCHER_ID = "doompi.default";
-const DEFAULT_INTERVAL_SECONDS = 300;
-const MIN_INTERVAL_SECONDS = 30;
-const MAX_INTERVAL_SECONDS = 3600;
-function notify(context, body, level = "info") {
-	return Promise.resolve(context.client.notify({
-		body,
-		level
-	}));
-}
-function numberInput(value, fallback) {
-	if (typeof value !== "string" || value.trim() === "") return fallback;
-	const parsed = Number(value);
-	if (!Number.isInteger(parsed) || parsed < MIN_INTERVAL_SECONDS || parsed > MAX_INTERVAL_SECONDS) throw new Error(`Interval must be between ${MIN_INTERVAL_SECONDS} and ${MAX_INTERVAL_SECONDS} seconds.`);
-	return parsed;
+async function prepareLoop(execution, 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 input = await execution.client.request({
+		kind: "input",
+		title: "Loop prompt",
+		multiline: true
+	}, request.signal);
+	const prompt = typeof input === "string" ? input.trim() : "";
+	if (!prompt || request.signal.aborted) return void 0;
+	if (cron) {
+		const expression = await execution.client.request({
+			kind: "input",
+			title: "Cron expression (five fields)",
+			initialValue: "0 * * * *"
+		}, request.signal);
+		if (typeof expression !== "string" || request.signal.aborted) return void 0;
+		const timezone = await execution.client.request({
+			kind: "input",
+			title: "Loop timezone",
+			initialValue: "UTC"
+		}, request.signal);
+		if (typeof timezone !== "string" || request.signal.aborted) return void 0;
+		return parseCronLoop({
+			prompt,
+			cron: expression,
+			timezone: timezone.trim() || "UTC"
+		});
+	}
+	const interval = await execution.client.request({
+		kind: "input",
+		title: "Loop interval in seconds",
+		initialValue: "300"
+	}, request.signal);
+	if (typeof interval !== "string" || request.signal.aborted) return void 0;
+	return parseIntervalLoop({
+		prompt,
+		intervalSeconds: Number(interval.trim() || "300")
+	});
 }
 function createSessionState(host) {
-	let launchers;
-	let defaultRegistration;
-	let unsubscribe;
-	let modeOwner;
-	const modeSelected = () => (host.context.selection.state?.["minor-mode"] ?? []).includes(MODE_ID);
-	const modeState = () => {
-		const launcherCount = launchers?.listLaunchers().length ?? 0;
-		const active = (launchers?.listInstances().length ?? 0) > 0;
-		const canStart = launcherCount > 0 || !modeSelected();
-		return {
-			activation: active ? "active" : "inactive",
-			condition: launchers?.listInstances().some(({ state }) => state !== "running") ? "queued" : "ready",
-			...active ? {
-				detail: `${launchers?.listInstances().length} active`,
-				color: "warning"
-			} : {},
-			actions: [{
-				id: "start",
-				enabled: canStart,
-				...canStart ? {} : { disabledReason: "No loop launchers are registered." }
-			}, {
-				id: "stop",
-				enabled: active,
-				...active ? {} : { disabledReason: "No loops are active." }
-			}]
-		};
-	};
-	/**
-	* The instances the activity dock lists.
-	*
-	* An empty list publishes an empty value rather than nothing, because the key
-	* being present is what keeps the group on screen as a launcher. The group
-	* declares no `hideWhenEmpty`, so an empty value is a header with no rows.
-	*/
-	const publishView = () => host.context.client.setStatus(LOOP_VIEW_STATUS_KEY, formatLoopStatusView(launchers?.listInstances() ?? []));
-	/** Both surfaces a loop shows up on: the minor-mode catalog and the activity dock. */
-	const publishMode = () => {
-		modeOwner?.publish();
-		publishView();
-	};
-	const startActivity = async (execution) => {
-		if (launchers !== void 0) return async () => void 0;
-		const dependencies = {
-			generation: `${execution.sessionId}:loop-launchers`,
-			createInstanceId: () => crypto.randomUUID(),
-			timestamp: () => (/* @__PURE__ */ new Date()).toISOString()
-		};
-		const service = createDoomLoopLaunchersService(dependencies);
-		const registration = service.register({
-			id: DEFAULT_LAUNCHER_ID,
-			source: SOURCE,
-			label: "Default loop",
-			description: "Run a prompt in this session on an interval.",
-			async launch({ instanceId, signal }) {
-				const promptValue = await execution.client.request({
-					kind: "input",
-					title: "Loop prompt",
-					multiline: true
-				}, signal);
-				const prompt = typeof promptValue === "string" ? promptValue.trim() : "";
-				if (!prompt || signal.aborted) return void 0;
-				const interval = numberInput(await execution.client.request({
-					kind: "input",
-					title: "Loop interval in seconds",
-					initialValue: String(DEFAULT_INTERVAL_SECONDS)
-				}, signal), DEFAULT_INTERVAL_SECONDS);
-				let stopped = false;
-				const tick = () => {
-					if (stopped || signal.aborted) return;
-					execution.session.prompt(prompt).catch((error) => {
-						notify(execution, `Loop pass failed: ${error instanceof Error ? error.message : String(error)}`, "warning");
-					});
-				};
-				const timer = setInterval(tick, interval * 1e3);
-				timer.unref?.();
-				tick();
-				return {
-					instanceId,
-					label: "Default loop",
-					detail: `every ${interval}s`,
-					stop() {
-						stopped = true;
-						clearInterval(timer);
-					}
-				};
-			}
-		});
-		launchers = service;
-		defaultRegistration = registration;
-		unsubscribe = service.subscribe(publishMode);
-		publishMode();
-		return async () => {
-			unsubscribe?.();
-			unsubscribe = void 0;
-			await registration.dispose("Headless loop activity stopped.");
-			await service.dispose("Headless loop activity stopped.");
-			if (launchers === service) launchers = void 0;
-			if (defaultRegistration === registration) defaultRegistration = void 0;
-			publishMode();
-		};
-	};
-	modeOwner = defineMinorMode({
+	const launchers = createDoomLoopLaunchersService({
+		generation: `${host.context.sessionId}:loop-launchers`,
+		createInstanceId: () => crypto.randomUUID(),
+		timestamp: () => (/* @__PURE__ */ new Date()).toISOString()
+	});
+	let disposed = false;
+	const modeSelected = () => !disposed && (host.context.selection.state?.["minor-mode"] ?? []).includes("loop.active");
+	const publishView = () => host.context.client.setStatus(LOOP_VIEW_STATUS_KEY, formatLoopStatusView(launchers.listInstances()));
+	const modeOwner = defineMinorMode({
 		descriptor: {
-			source: SOURCE,
-			id: MODE_ID,
+			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: "start",
-				label: "Start",
-				description: "Start a loop with a registered launcher.",
+				id: "activate",
+				label: "Activate",
+				description: "Expose loop tools to the agent.",
 				contexts: ["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: "stop",
-				label: "Stop",
-				description: "Stop one active loop instance.",
+				id: "deactivate",
+				label: "Deactivate",
+				description: "Hide agent loop tools. Existing loops and manual controls remain available.",
 				contexts: ["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: modeState,
-		async handleAction(_runtime, actionId, argumentsValue, { signal }) {
+		state: () => ({
+			activation: modeSelected() ? "active" : "inactive",
+			condition: "ready",
+			...modeSelected() ? {
+				detail: `${launchers.listInstances().length} loops`,
+				color: "accent"
+			} : {},
+			actions: [{
+				id: "activate",
+				enabled: !modeSelected(),
+				...modeSelected() ? { disabledReason: "Loop mode is already active." } : {}
+			}, {
+				id: "deactivate",
+				enabled: modeSelected(),
+				...modeSelected() ? {} : { disabledReason: "Loop mode is not active." }
+			}]
+		}),
+		async handleAction(_runtime, actionId, _arguments, { signal }) {
 			signal.throwIfAborted();
-			if (actionId === "start" && !launchers) {
-				const modes = (host.context.selection.state?.["minor-mode"] ?? []).filter((mode) => mode !== MODE_ID);
-				await host.changeSelection({
-					axis: "state",
-					key: "minor-mode",
-					values: [...modes, MODE_ID]
-				});
-			}
-			if (!launchers) throw new Error("Loop activity is not active.");
-			if (actionId === "start") {
-				const instance = await launchers.launch(String(argumentsValue.launcherId ?? ""), argumentsValue.instanceId ? { instanceId: String(argumentsValue.instanceId) } : {});
-				publishMode();
-				return { message: instance ? `Loop '${instance.instanceId}' started.` : "Loop launch was cancelled." };
-			}
-			if (actionId === "stop") {
-				const stopped = await launchers.stop(String(argumentsValue.instanceId ?? ""), String(argumentsValue.reason ?? "Stopped through minor_mode."));
-				if (stopped && launchers.listInstances().length === 0) {
-					const modes = (host.context.selection.state?.["minor-mode"] ?? []).filter((mode) => mode !== MODE_ID);
-					await host.changeSelection({
-						axis: "state",
-						key: "minor-mode",
-						values: modes
+			if (actionId !== "activate" && actionId !== "deactivate") throw new Error(`Unknown loop mode action: ${actionId}`);
+			const modes = (host.context.selection.state?.["minor-mode"] ?? []).filter((mode) => mode !== MODE_STATUS_ID);
+			await host.changeSelection({
+				axis: "state",
+				key: "minor-mode",
+				values: actionId === "activate" ? [...modes, MODE_STATUS_ID] : modes
+			});
+			modeOwner.publish();
+			return { message: actionId === "activate" ? "Loop tools activated." : "Loop tools deactivated. Existing loops are unchanged." };
+		}
+	}).createOwner(void 0);
+	const publish = () => {
+		if (disposed) return;
+		modeOwner.publish();
+		publishView();
+	};
+	const unsubscribe = launchers.subscribe(publish);
+	let submitting = false;
+	for (const cron of [false, true]) 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 a prompt in this session on an interval.",
+		inputSchema: { ...cron ? CronLoopSchema : IntervalLoopSchema },
+		async launch(request) {
+			const execution = host.context;
+			const prepared = await prepareLoop(execution, request, cron);
+			if (!prepared || request.signal.aborted) return void 0;
+			let stopped = false;
+			const tick = async () => {
+				if (stopped || request.signal.aborted || submitting) return;
+				submitting = true;
+				try {
+					const activity = await execution.session.activity();
+					if (stopped || request.signal.aborted || !activity.isIdle || activity.hasPendingMessages) return;
+					await execution.session.prompt(prepared.prompt);
+				} catch (error) {
+					await execution.client.notify({
+						body: `Loop pass failed: ${error instanceof Error ? error.message : String(error)}`,
+						level: "warning"
 					});
+				} finally {
+					submitting = false;
+				}
+			};
+			let stopTimer;
+			let detail;
+			if ("cron" in prepared) {
+				const job = new Cron(prepared.cron, {
+					timezone: prepared.timezone,
+					unref: true
+				}, tick);
+				if (job.nextRun() === null) {
+					job.stop();
+					throw new Error("Cron expression has no future run.");
 				}
-				publishMode();
-				return { message: stopped ? "Loop stopped." : "Loop instance was not active." };
+				stopTimer = () => {
+					job.stop();
+				};
+				detail = `${prepared.cron} (${prepared.timezone})`;
+			} else {
+				const timer = setInterval(() => {
+					tick();
+				}, prepared.intervalSeconds * 1e3);
+				timer.unref?.();
+				stopTimer = () => clearInterval(timer);
+				detail = `every ${prepared.intervalSeconds}s`;
+				tick();
 			}
-			throw new Error(`Unknown loop mode action: ${actionId}`);
+			return {
+				instanceId: request.instanceId,
+				label: cron ? "Cron loop" : "Default loop",
+				detail,
+				stop() {
+					stopped = true;
+					stopTimer();
+				}
+			};
 		}
-	}).createOwner(void 0);
+	});
 	return {
-		services: [serverMinorModes([modeOwner])],
+		loopTools: createLoopTools(() => launchers, () => {
+			if (!modeSelected()) throw new Error("Enable Loop minor mode before using agent loop tools.");
+		}).map((tool) => ({
+			...tool,
+			when: {
+				state: { "minor-mode": MODE_STATUS_ID },
+				attribution: {
+					kind: "minor",
+					mode: MODE_STATUS_ID
+				}
+			}
+		})),
+		services: [(context) => {
+			context.plugin((provider) => {
+				provider.provide(DOOM_LOOP_LAUNCHERS_SERVICE, launchers);
+			});
+			context.effect(() => host.subscribeSelection(publish));
+		}, serverMinorModes([modeOwner])],
 		resources: [{
 			when: {
-				state: { "minor-mode": MODE_ID },
+				state: { "minor-mode": MODE_STATUS_ID },
 				attribution: {
 					kind: "minor",
-					mode: MODE_ID
+					mode: MODE_STATUS_ID
 				}
 			},
 			name: "doompi-use-loop",
@@ -216,29 +206,19 @@ function createSessionState(host) {
 			read: () => readPackageResource(import.meta.url, "src/prompts/doompi-use-loop/SKILL.md")
 		}],
 		activities: [{
-			when: {
-				state: { "minor-mode": MODE_ID },
-				attribution: {
-					kind: "minor",
-					mode: MODE_ID
-				}
-			},
 			name: "doompi-loop",
-			start: startActivity
+			async start() {
+				publish();
+				return async () => {
+					await launchers.stopAll("Session loop activity stopped.");
+					publish();
+				};
+			}
 		}],
 		commands: [{
 			name: START_COMMAND_NAME,
-			description: "Start a registered loop.",
+			description: "Start a registered loop manually.",
 			async execute(args, execution) {
-				if (!launchers) {
-					const modes = host.context.selection.state?.["minor-mode"] ?? [];
-					await host.changeSelection({
-						axis: "state",
-						key: "minor-mode",
-						values: [...modes, MODE_ID]
-					});
-				}
-				if (!launchers) throw new Error("Loop activity is not active.");
 				const available = launchers.listLaunchers();
 				const selected = args.trim() || await execution.client.request({
 					kind: "select",
@@ -248,47 +228,57 @@ function createSessionState(host) {
 						value: entry.id
 					}))
 				});
-				const launcherId = args.trim() || (typeof selected === "string" ? selected : "");
-				if (!launcherId) return;
-				const instance = await launchers.launch(launcherId);
-				publishMode();
-				await notify(execution, instance ? `Loop '${instance.instanceId}' started.` : "Loop launch was cancelled.");
+				if (typeof selected !== "string" || !selected) return;
+				const instance = await launchers.launch(selected);
+				await execution.client.notify({
+					body: instance ? `Loop '${instance.instanceId}' started.` : "Loop launch was cancelled.",
+					level: "info"
+				});
 			}
 		}, {
 			name: LIST_COMMAND_NAME,
-			description: "List and stop active loops.",
-			async execute(_args, execution) {
-				const instances = launchers?.listInstances() ?? [];
-				await notify(execution, instances.length === 0 ? "No loops are active." : JSON.stringify(instances, null, 2));
+			description: "List or stop session loops. Usage: /loops [stop instanceId].",
+			async execute(args, execution) {
+				const parts = args.trim().split(/\s+/u);
+				if (parts[0] === "stop" && parts.length === 2) {
+					const stopped = await launchers.stop(parts[1], "Stopped manually.");
+					await execution.client.notify({
+						body: stopped ? "Loop stopped." : "Loop instance was not active.",
+						level: "info"
+					});
+					return;
+				}
+				if (args.trim()) throw new Error("Usage: /loops [stop instanceId]");
+				const instances = launchers.listInstances();
+				await execution.client.notify({
+					body: instances.length === 0 ? "No loops are active." : JSON.stringify(instances, null, 2),
+					level: "info"
+				});
 			}
 		}],
 		hooks: [{
 			event: "session_start",
 			async handle() {
-				publishView();
+				publish();
 			}
 		}, {
-			when: {
-				state: { "minor-mode": MODE_ID },
-				attribution: {
-					kind: "minor",
-					mode: MODE_ID
-				}
-			},
 			event: "session_shutdown",
 			async handle() {
-				await launchers?.stopAll("Headless session shutdown.");
+				await launchers.stopAll("Headless session shutdown.");
 			}
 		}],
+		onStart: publish,
 		async onDispose() {
-			await defaultRegistration?.dispose("Headless loop facet disposed.");
-			await launchers?.dispose("Headless loop facet disposed.");
+			if (disposed) return;
+			disposed = true;
+			unsubscribe();
+			await launchers.dispose("Headless loop facet disposed.");
 		}
 	};
 }
 //#endregion
 //#region src/extensions/workspaces/sessions/(backend)/_lib/runtime.server.ts
-var runtime_server_default = (({ agent }) => agent ? createSessionState(agent) : {});
+var runtime_server_default = (({ agent }) => agent ? createSessionState(agent) : { loopTools: [] });
 //#endregion
 //#region src/extensions/workspaces/sessions/(backend)/root.server.ts
 var root_server_default = defineRoot((context) => {
@@ -318,14 +308,23 @@ var session_start_server_default = defineRoutedContribution((context) => context
 //#region src/extensions/workspaces/sessions/(backend)/resource/doompi-use-loop.server.ts
 var doompi_use_loop_server_default = defineRoutedContribution((context) => context.root.resources?.[0], { cardinality: "optional" });
 //#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/loop-list.server.ts
+var loop_list_server_default = defineTool((context) => context.root.loopTools[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/loop-start.server.ts
+var loop_start_server_default = defineTool((context) => context.root.loopTools[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/loop-stop.server.ts
+var loop_stop_server_default = defineTool((context) => context.root.loopTools[2]);
+//#endregion
 //#region generated/server.ts
 const at = (value, context) => typeof value === "function" ? value(context) : value;
 /* v8 ignore next -- generated normalization branch */
 const defined = (values) => values.filter((value) => value !== void 0);
-const via = (identity, value) => ({
+const via = (identity, value) => value === void 0 ? void 0 : {
 	...identity,
 	...value
-});
+};
 const facet = defineServerPlugin({
 	name: "@agimon-ai/doompi-loop",
 	session: async (context) => {
@@ -345,6 +344,13 @@ const facet = defineServerPlugin({
 			get resources() {
 				return defined([at(doompi_use_loop_server_default, contextSession)]);
 			},
+			get tools() {
+				return [
+					via({ name: "loop_list" }, at(loop_list_server_default, contextSession)),
+					via({ name: "loop_start" }, at(loop_start_server_default, contextSession)),
+					via({ name: "loop_stop" }, at(loop_stop_server_default, contextSession))
+				];
+			},
 			services: [...scopeSession.services ?? []],
 			get activities() {
 				return [...scopeSession.activities ?? []];