@agimon-ai/po-task 0.0.0-alpha.0

package/dist/extensions/server.cjs

@@ -0,0 +1,569 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_paths = require("../paths-CSya2l9_.cjs");
+const require_config = require("../config-CdX-Bv8q.cjs");
+const require_telemetry = require("../telemetry-Ca0I3Tqo.cjs");
+const require_delegation = require("../delegation-DsnKjMbJ.cjs");
+const require_taskResult = require("../taskResult-D2G7b4w-.cjs");
+const require_task = require("../task-UvW877Ez.cjs");
+const require_reducer = require("../reducer-BV0YIZ2o.cjs");
+const require_taskStore = require("../taskStore-DjU60rMm.cjs");
+const require_logSinkTelemetry = require("../logSinkTelemetry-B23qGiP-.cjs");
+let _agimon_ai_po_core_delegation = require("@agimon-ai/po-core/delegation");
+let node_path = require("node:path");
+node_path = require_paths.__toESM(node_path, 1);
+let _agimon_ai_po_core_serverFacet = require("@agimon-ai/po-core/serverFacet");
+let _agimon_ai_po_core_extensionFile = require("@agimon-ai/po-core/extensionFile");
+let _agimon_ai_po_core_backgroundWork = require("@agimon-ai/po-core/backgroundWork");
+let _agimon_ai_po_core_contextContributions = require("@agimon-ai/po-core/contextContributions");
+let _agimon_ai_po_core_readiness = require("@agimon-ai/po-core/readiness");
+let node_crypto = require("node:crypto");
+let typebox_value = require("typebox/value");
+//#region src/services/contextContribution/index.ts
+const TASK_CONTEXT_CONTRIBUTION_SOURCE = "@agimon-ai/po-task";
+const TASK_CONTEXT_CONTRIBUTION_ID = "active-tasks";
+const TASK_CONTEXT_CONTRIBUTION_LABEL = "Active tasks";
+function activeTaskSnapshots(tasks) {
+	return tasks.filter((task) => task.status === "pending" || task.status === "in_progress" || task.status === "failed").map((task) => ({
+		id: task.id,
+		status: task.status,
+		subject: task.subject,
+		...task.activeForm ? { activeForm: task.activeForm } : {},
+		...task.owner ? { owner: task.owner } : {},
+		...task.blockedBy?.length ? { blockedBy: task.blockedBy } : {},
+		...task.delegation ? { delegation: {
+			agent: task.delegation.agent,
+			state: task.delegation.state,
+			...task.delegation.result?.error ? { error: task.delegation.result.error } : {}
+		} } : {}
+	}));
+}
+function formatTaskSnapshots(tasks) {
+	if (tasks.length === 0) return "(no active tasks)";
+	return tasks.map((task) => {
+		const details = [
+			task.activeForm ? `active: ${task.activeForm}` : void 0,
+			task.owner ? `owner: ${task.owner}` : void 0,
+			task.blockedBy?.length ? `blocked by: ${task.blockedBy.join(", ")}` : void 0,
+			task.delegation ? `delegation: ${task.delegation.agent} (${task.delegation.state})` : void 0,
+			task.delegation?.error ? `error: ${task.delegation.error}` : void 0
+		].filter((value) => Boolean(value));
+		return `- #${task.id} [${task.status}] ${task.subject}${details.length > 0 ? ` | ${details.join(" | ")}` : ""}`;
+	}).join("\n");
+}
+/** Builds Task's bounded, synchronous contribution from its in-memory store snapshot. */
+function createTaskContextContribution(readTasks) {
+	return Object.freeze({
+		source: TASK_CONTEXT_CONTRIBUTION_SOURCE,
+		id: TASK_CONTEXT_CONTRIBUTION_ID,
+		label: TASK_CONTEXT_CONTRIBUTION_LABEL,
+		order: 100,
+		snapshot: () => formatTaskSnapshots(activeTaskSnapshots(readTasks()))
+	});
+}
+//#endregion
+//#region src/services/delegationPlatform/index.ts
+function formatBriefPath(entry, cwd) {
+	if (!node_path.default.isAbsolute(entry)) return node_path.default.normalize(entry);
+	const relative = node_path.default.relative(cwd, entry);
+	return relative && !relative.startsWith("..") ? relative : entry;
+}
+/** Supply Node-owned process and path facilities to the host-neutral manager. */
+function createNodeDelegationPlatform(environment = process.env) {
+	return {
+		environment,
+		processId: process.pid,
+		createRequestId: node_crypto.randomUUID,
+		formatBriefPath
+	};
+}
+//#endregion
+//#region src/types/webTasks.ts
+/** Browser-safe task view published by the cockpit hub channel. */
+const TASKS_CHANNEL_TYPE = "task_graph";
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/_lib/root.server.ts
+const SOURCE = "@agimon-ai/po-task";
+/** The notification body: one line, since `client.notify` collapses the rest anyway. */
+function headlineOf(content) {
+	return content.split("\n").find((line) => line.trim().length > 0) ?? content;
+}
+const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ host: serverHost, agent: host, signal: pluginSignal }) => {
+	if (!host) throw new Error("Task session requires the headless host.");
+	const execution = host.context;
+	if (serverHost.context.directEvents === void 0) throw new Error("Task headless facet requires the session direct event bus.");
+	const directEvents = serverHost.context.directEvents;
+	const reporter = require_logSinkTelemetry.createTaskErrorReporter({
+		cwd: execution.cwd,
+		env: execution.environment
+	});
+	const report = require_logSinkTelemetry.toFailureReporter(reporter);
+	let active = true;
+	let disposed = false;
+	let generation = 0;
+	let unwatch;
+	let backgroundService;
+	let background;
+	let serviceContext;
+	let startup = Promise.resolve();
+	let startupAbort = new AbortController();
+	const ownedReadiness = (0, _agimon_ai_po_core_readiness.createDoomReadinessCoordinator)({ notify: (notification) => execution.client.notify({
+		body: notification.error?.message ?? notification.diagnostics.join("; "),
+		level: "warning"
+	}) });
+	const refresh = () => {
+		if (!active || disposed) return;
+		execution.client.setStatus(SOURCE, `tasks: ${store.snapshot.tasks.length}`);
+		background?.update();
+	};
+	const registerBackground = () => {
+		if (!active || disposed || !backgroundService || background) return;
+		background = backgroundService.register({
+			provider: require_delegation.BACKGROUND_WORK_PROVIDER,
+			listActiveWork: () => active && !disposed ? manager.listActiveWork() : []
+		});
+	};
+	const maxTasks = require_config.getMaxTasks(execution.environment);
+	const store = new require_taskStore.TaskStore({
+		cwd: execution.cwd,
+		env: execution.environment,
+		report
+	});
+	store.configureSession(require_paths.resolveSessionKey(execution.sessionId, execution.environment));
+	let notifications = Promise.resolve();
+	const manager = new require_delegation.DelegationManager({
+		store,
+		cwd: execution.cwd,
+		platform: createNodeDelegationPlatform(execution.environment),
+		getSessionId: () => execution.sessionId,
+		report,
+		notify: (message, options) => {
+			const ownGeneration = generation;
+			const isCurrent = () => active && !disposed && !pluginSignal?.aborted && generation === ownGeneration;
+			notifications = notifications.then(async () => {
+				if (!isCurrent()) return;
+				await execution.client.notify({
+					body: headlineOf(message.content),
+					level: "info"
+				});
+				if (!isCurrent()) return;
+				await execution.session.appendCustomEntry(message.customType, { content: message.content });
+				if (!isCurrent() || options?.triggerTurn === false) return;
+				if (!execution.session.admitPrompt) throw new Error("The session cannot admit a task notification.");
+				await execution.session.admitPrompt(message.content, "steer");
+			}).catch((error) => {
+				if (isCurrent()) execution.client.notify({
+					body: String(error),
+					level: "warning"
+				});
+			});
+		},
+		onChange: refresh,
+		runTimeoutMs: require_config.getDelegationTimeoutMs(execution.environment),
+		onNotifyError: (error, taskId) => {
+			reporter.recordNotificationError(error, taskId);
+			if (active && !disposed) execution.client.notify({
+				body: String(error),
+				level: "warning"
+			});
+		}
+	});
+	return {
+		value: {
+			store,
+			manager,
+			maxTasks
+		},
+		services: [(serviceContextOwner) => {
+			serviceContext = serviceContextOwner;
+			serviceContextOwner.inject([_agimon_ai_po_core_contextContributions.DOOM_CONTEXT_CONTRIBUTIONS_SERVICE], (context) => {
+				const registration = (0, _agimon_ai_po_core_contextContributions.requireDoomContextContributions)(context).register(createTaskContextContribution(() => active && !disposed ? store.snapshot.tasks : []));
+				return () => registration.dispose();
+			});
+			serviceContextOwner.inject([_agimon_ai_po_core_backgroundWork.DOOM_BACKGROUND_WORK_SERVICE], (context) => {
+				const service = (0, _agimon_ai_po_core_backgroundWork.readDoomBackgroundWorkService)(context);
+				if (!service) return void 0;
+				backgroundService = service;
+				registerBackground();
+				return () => {
+					if (backgroundService !== service) return;
+					background?.dispose();
+					background = void 0;
+					backgroundService = void 0;
+				};
+			});
+			serviceContextOwner.inject([_agimon_ai_po_core_delegation.DOOM_DELEGATION_SERVICE], (serviceContext) => {
+				const service = (0, _agimon_ai_po_core_delegation.readDoomDelegationService)(serviceContext);
+				if (service) return manager.bind(serviceContext, service);
+			});
+		}],
+		activities: [{
+			name: SOURCE,
+			async start(activityContext) {
+				if (disposed) throw new Error("Task session is disposed.");
+				active = true;
+				const ownGeneration = ++generation;
+				startupAbort.abort();
+				const controller = new AbortController();
+				startupAbort = controller;
+				await Promise.allSettled([startup]);
+				startup = ((serviceContext && (0, _agimon_ai_po_core_readiness.readDoomReadinessCoordinator)(serviceContext)) ?? ownedReadiness).start(SOURCE, `${execution.sessionId}:${ownGeneration}`, async (signal) => {
+					const isCurrent = () => !disposed && !pluginSignal?.aborted && active && generation === ownGeneration && !signal.aborted && !controller.signal.aborted;
+					const diagnostics = [];
+					const degrade = async (stage, operation) => {
+						try {
+							await operation();
+						} catch (error) {
+							diagnostics.push(`Task ${stage} failed: ${String(error)}`);
+							report.warn(require_telemetry.TASK_EVENT.sessionStartDegraded, error, { "task.stage": stage });
+						}
+					};
+					try {
+						if (!isCurrent()) return { value: void 0 };
+						store.configureSession(require_paths.resolveSessionKey(activityContext.sessionId, activityContext.environment));
+						manager.setCwd(activityContext.cwd);
+						const cleanup = await require_paths.removeLegacyStoreDirectoryAsync(store.storePath, activityContext.cwd);
+						if (!isCurrent()) return { value: void 0 };
+						const sweep = require_paths.hasStorePathOverride(activityContext.environment) ? { errors: [] } : await require_paths.sweepStoreFilesAsync(store.storePath, require_config.getStoreTtlMs(activityContext.environment));
+						for (const error of [...cleanup.errors, ...sweep.errors]) {
+							diagnostics.push(error);
+							report.warn(require_telemetry.TASK_EVENT.storeSweepFailed, new Error(error));
+						}
+						if (!isCurrent()) return { value: void 0 };
+						await degrade("store_read", async () => {
+							const errors = [];
+							await store.readAsync(isCurrent, (error) => errors.push(error));
+							if (errors.length > 0) throw new Error(String(errors[0]), { cause: errors[0] });
+						});
+						if (!isCurrent()) return { value: void 0 };
+						unwatch?.();
+						unwatch = store.onExternalChange(() => {
+							refresh();
+							if (isCurrent()) directEvents.publish(TASKS_CHANNEL_TYPE, execution.sessionId, store.snapshot);
+						});
+						await degrade("reconcile", () => manager.reconcile(isCurrent));
+						if (!isCurrent()) return { value: void 0 };
+						registerBackground();
+						refresh();
+						directEvents.publish(TASKS_CHANNEL_TYPE, execution.sessionId, store.snapshot);
+						return {
+							value: void 0,
+							diagnostics
+						};
+					} catch (error) {
+						if (!isCurrent()) return { value: void 0 };
+						report.error(require_telemetry.TASK_EVENT.sessionStartFailed, error);
+						throw error;
+					}
+				}).wait();
+				await Promise.allSettled([startup]);
+				return () => {
+					if (ownGeneration !== generation) return;
+					active = false;
+					generation += 1;
+					controller.abort();
+					unwatch?.();
+					unwatch = void 0;
+					background?.dispose();
+					background = void 0;
+					manager.reset();
+					execution.client.setStatus(SOURCE, void 0);
+				};
+			}
+		}],
+		async onDispose() {
+			if (disposed) return;
+			disposed = true;
+			active = false;
+			generation += 1;
+			startupAbort.abort();
+			await Promise.allSettled([startup]);
+			unwatch?.();
+			background?.dispose();
+			manager.dispose();
+			store.dispose();
+			await ownedReadiness.dispose();
+			await reporter.shutdown();
+		}
+	};
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = (0, _agimon_ai_po_core_extensionFile.defineRoot)(root);
+//#endregion
+//#region src/extensions/(backend)/channel/_lib/task-graph.ts
+function isTaskDocument(value) {
+	return typeof value === "object" && value !== null && typeof value.rev === "number" && Array.isArray(value.tasks);
+}
+function present(document) {
+	return {
+		tasks: document.tasks.flatMap((task) => {
+			if (task.status === "deleted") return [];
+			const view = {
+				id: task.id,
+				subject: task.subject,
+				status: task.status,
+				blockedBy: task.blockedBy ?? []
+			};
+			if (task.description) view.description = task.description;
+			if (task.activeForm) view.activeForm = task.activeForm;
+			if (task.owner) view.owner = task.owner;
+			if (task.updatedAt) view.updatedAt = task.updatedAt;
+			if (task.delegation) view.delegation = {
+				...task.delegation.agent === void 0 ? {} : { agent: task.delegation.agent },
+				...task.delegation.state === void 0 ? {} : { state: task.delegation.state }
+			};
+			return [view];
+		}),
+		rev: document.rev
+	};
+}
+/** Publishes each managed session's durable task graph and follows direct session commits. */
+function createTasksChannel(options = {}) {
+	return {
+		frameType: TASKS_CHANNEL_TYPE,
+		start(host) {
+			const stores = /* @__PURE__ */ new Map();
+			const open = (scope) => {
+				if (stores.has(scope.sessionId)) return;
+				let store = options.storeFor?.(scope);
+				if (store === void 0) {
+					if (scope.environment === void 0) throw new Error(`Task channel requires an admitted environment for session '${scope.sessionId}'.`);
+					store = new require_taskStore.TaskStore({
+						cwd: scope.cwd,
+						env: scope.environment,
+						storePath: require_paths.resolveStorePath(scope.cwd, scope.environment, scope.sessionId)
+					});
+				}
+				store.read();
+				const source = {
+					store,
+					unsubscribe: () => void 0
+				};
+				stores.set(scope.sessionId, source);
+				source.unsubscribe = host.directEvents.subscribe(TASKS_CHANNEL_TYPE, scope.sessionId, (payload) => {
+					if (!isTaskDocument(payload)) return;
+					const current = stores.get(scope.sessionId);
+					if (current === void 0) return;
+					current.latest = payload;
+					host.publish(scope.sessionId, present(payload));
+				}, { replayLatest: true });
+			};
+			const close = (sessionId) => {
+				const source = stores.get(sessionId);
+				if (!source) return;
+				source.unsubscribe();
+				source.store.dispose();
+				stores.delete(sessionId);
+			};
+			for (const scope of host.sessions()) open(scope);
+			return {
+				payloadFor(scope) {
+					open(scope);
+					const source = stores.get(scope.sessionId);
+					const document = source?.latest ?? source?.store.snapshot;
+					return document === void 0 ? void 0 : present(document);
+				},
+				sessionAdded: open,
+				sessionRemoved: close,
+				close() {
+					for (const sessionId of stores.keys()) close(sessionId);
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/extensions/(backend)/channel/task-graph.server.ts
+var task_graph_server_default = (0, _agimon_ai_po_core_extensionFile.defineChannel)(createTasksChannel);
+//#endregion
+//#region src/services/taskTool/index.ts
+function output(value) {
+	if (typeof value === "object" && value !== null && "content" in value) return value;
+	return {
+		content: [{
+			type: "text",
+			text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+		}],
+		details: value
+	};
+}
+function failure(error) {
+	return {
+		content: [{
+			type: "text",
+			text: error instanceof Error ? error.message : String(error)
+		}],
+		isError: true
+	};
+}
+async function reducerAction(store, action, params, maxTasks) {
+	const { document, value } = await store.mutate((current) => {
+		const result = require_reducer.applyTaskMutation(current, action, params, void 0, maxTasks);
+		return {
+			...require_reducer.isCommittingOp(result.op) ? { document: result.document } : {},
+			value: result
+		};
+	});
+	if (value.op.kind === "error") throw new Error(value.op.message);
+	return require_taskResult.buildToolResult(action, params, document, value.op);
+}
+async function assignmentBatch(manager, assignments, signal) {
+	const result = [];
+	for (const [index, assignment] of assignments.entries()) try {
+		const outcome = await manager.assign(assignment.id, {
+			agent: assignment.agent,
+			inlineAgent: assignment.inlineAgent,
+			instructions: assignment.instructions,
+			relevantFiles: assignment.relevantFiles,
+			priorFindings: assignment.priorFindings,
+			model: assignment.model,
+			...assignment.context === "fork" || assignment.context === "fresh" ? { context: assignment.context } : {},
+			signal
+		});
+		result.push({
+			index,
+			id: assignment.id,
+			agent: assignment.agent,
+			...outcome
+		});
+	} catch (error) {
+		result.push({
+			index,
+			id: assignment.id,
+			agent: assignment.agent,
+			ok: false,
+			message: String(error)
+		});
+	}
+	return result;
+}
+function createHeadlessTaskTool(store, manager, maxTasks) {
+	return {
+		name: "task",
+		label: "Task",
+		description: "Maintain a persistent task graph and delegate ready tasks to background agents.",
+		parameters: require_task.TaskParamsSchema,
+		promptSnippet: "Track complex work persistently and delegate ready tasks",
+		executionMode: "serial",
+		async execute(_toolCallId, rawParams, signal, onUpdate) {
+			if (!(0, typebox_value.Check)(require_task.TaskParamsSchema, rawParams)) return failure("Invalid task parameters.");
+			const params = rawParams;
+			try {
+				if ((params.action === "assign" || params.action === "cancel") && !manager) throw new Error("Delegation is not available on this connection.");
+				if (params.action === "assign") {
+					if (!params.assignments?.length) throw new Error("assign requires a non-empty assignments[] array");
+					onUpdate?.(output(`Delegating ${params.assignments.length} task${params.assignments.length === 1 ? "" : "s"}...`));
+					const items = await assignmentBatch(manager, params.assignments, signal);
+					const assigned = items.filter((item) => item.ok).map((item) => item.id);
+					const text = require_taskResult.formatAssignmentResults(items);
+					if (assigned.length === 0) throw new Error(text);
+					return require_taskResult.buildAssignmentResult(params, store.snapshot, text, {
+						assigned,
+						failed: items.length - assigned.length
+					});
+				}
+				if (params.action === "cancel") {
+					const outcome = await manager.cancel(params.id ?? NaN);
+					if (!outcome.ok) throw new Error(outcome.message);
+					return require_taskResult.buildTextResult("cancel", params, store.snapshot, outcome.message);
+				}
+				return reducerAction(store, params.action, params, maxTasks);
+			} catch (error) {
+				return failure(error);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/command/_lib/tasks.server.ts
+var tasks_server_default$1 = (context) => ({
+	name: require_task.COMMAND_NAME,
+	description: "List or clear the persistent task graph.",
+	async execute(args, commandContext) {
+		const action = args.trim() === "clear" ? "clear" : "list";
+		const content = (await reducerAction(context.root.store, action, { action }, context.root.maxTasks)).content[0];
+		await commandContext.client.notify({
+			body: content?.type === "text" ? content.text : "No tasks",
+			level: "info"
+		});
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/command/tasks.server.ts
+var tasks_server_default = (0, _agimon_ai_po_core_extensionFile.defineServerCommand)(tasks_server_default$1);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/_lib/task-board.server.ts
+var task_board_server_default$1 = (context) => ({
+	name: "po/task-board",
+	kind: "context",
+	/**
+	* The same bounded projection the Pi facet renders: open work only, one line each.
+	* Dumping the whole TaskDocument put every completed task plus the store's own
+	* version/rev/nextId bookkeeping in the prompt, and an idle board still cost a
+	* paragraph. '' is dropped by the prompt composer.
+	*/
+	read: () => {
+		const rendered = formatTaskSnapshots(activeTaskSnapshots(context.root.store.snapshot.tasks));
+		return rendered === "(no active tasks)" ? "" : rendered;
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/task-board.server.ts
+var task_board_server_default = (0, _agimon_ai_po_core_extensionFile.defineResource)(task_board_server_default$1);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/_lib/task.server.ts
+var task_server_default$1 = (0, _agimon_ai_po_core_extensionFile.defineServerTool)((context) => createHeadlessTaskTool(context.root.store, context.root.manager, context.root.maxTasks));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/task.server.ts
+var task_server_default = (0, _agimon_ai_po_core_extensionFile.defineServerTool)(task_server_default$1);
+//#endregion
+//#region generated/server.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const facet = (0, _agimon_ai_po_core_serverFacet.defineServerPlugin)({
+	name: "@agimon-ai/po-task",
+	providerOverrides: (0, _agimon_ai_po_core_serverFacet.composeServerProviderOverrides)(root_server_default),
+	global: () => ({ get channels() {
+		return [() => via({ frameType: "task_graph" }, task_graph_server_default())];
+	} }),
+	workspace: () => ({ get channels() {
+		return [() => via({ frameType: "task_graph" }, task_graph_server_default())];
+	} }),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...(0, _agimon_ai_po_core_extensionFile.composeRootHooks)(scopeSession),
+			get channels() {
+				return [() => via({ frameType: "task_graph" }, task_graph_server_default())];
+			},
+			get commands() {
+				return [via({ name: "tasks" }, at(tasks_server_default, contextSession))];
+			},
+			get resources() {
+				return [at(task_board_server_default, contextSession)];
+			},
+			get tools() {
+				return [via({ name: "task" }, at(task_server_default, contextSession))];
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+exports.default = facet;
+exports.facet = facet;
+
+//# sourceMappingURL=server.cjs.map