@danypops/papyrus 0.7.0 → 0.9.0

package/src/task-service.ts

@@ -1,4 +1,13 @@
-import { TASK_EXECUTION_MAX_DEGREE, TASK_EXECUTION_MAX_EDGES, TASK_EXECUTION_MAX_NODES, TASK_SCOPE_MAX_TASKS } from "./constants.ts";
+import {
+	TASK_BODY_MAX_LENGTH,
+	TASK_EXECUTION_MAX_DEGREE,
+	TASK_EXECUTION_MAX_EDGES,
+	TASK_EXECUTION_MAX_NODES,
+	TASK_LABEL_MAX_COUNT,
+	TASK_LABEL_MAX_LENGTH,
+	TASK_SCOPE_MAX_TASKS,
+	TASK_TITLE_MAX_LENGTH,
+} from "./constants.ts";
 import type { Artifact } from "./domain/artifact.ts";
 import { checklistEntries, validateChecklist, type Checklist, type ProofReference } from "./domain/checklist.ts";
 import type { Gate, GateResult } from "./domain/gate.ts";
@@ -6,11 +15,17 @@ import type { AppendTaskEvent, TaskEventContext, TaskHistoryPage, TaskHistoryQue
 import { normalizeProjectRoot, taskScopeLabel, type TaskScopeSource, type TaskViewMode, type TaskViewSelection } from "./domain/task-scope.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import type { GateRunner } from "./ports/gate-runner.ts";
-import { InMemoryTaskFocusStore, type TaskFocusStore } from "./ports/task-focus-store.ts";
+import { InMemoryTaskFocusStore, type TaskFocusStatus, type TaskFocusStore } from "./ports/task-focus-store.ts";
 import { InMemoryTaskEventStore, type TaskEventStore } from "./ports/task-event-store.ts";
 import { InMemoryTaskScopeStore, type TaskScopeStore } from "./ports/task-scope-store.ts";
 import { assertDependencyEdgeAllowed } from "./task-execution.ts";
 
+export interface UpdateTaskInput {
+	title?: string;
+	body?: string;
+	labels?: string[];
+}
+
 export interface TaskFilter {
 	status?: string;
 	text?: string;
@@ -53,6 +68,13 @@ export interface ChecklistReview {
 	reason?: string;
 }
 
+export interface TaskFocus {
+	artifact: Artifact;
+	status: TaskFocusStatus;
+	updatedAt: string;
+	pauseReason?: string;
+}
+
 export interface TaskCompletionOptions {
 	focusSuccessor?: boolean;
 	gateDeadlineMs?: number;
@@ -70,6 +92,7 @@ export interface TaskCompletion {
 export interface TaskNode {
 	task: Artifact;
 	active?: boolean;
+	focusStatus?: TaskFocusStatus;
 	parentIds: string[];
 	childIds: string[];
 	dependencyIds: string[];
@@ -138,6 +161,28 @@ export class Tasks {
 		});
 	}
 
+	update(id: string, input: UpdateTaskInput, context: TaskEventContext = {}): Artifact {
+		const fields = (["title", "body", "labels"] as const).filter((field) => input[field] !== undefined);
+		if (fields.length === 0) throw new Error("task update requires title, body, or labels");
+		if (input.title !== undefined && (input.title.trim().length === 0 || input.title.length > TASK_TITLE_MAX_LENGTH)) {
+			throw new Error(`title must be between 1 and ${TASK_TITLE_MAX_LENGTH} characters`);
+		}
+		if (input.body !== undefined && input.body.length > TASK_BODY_MAX_LENGTH) throw new Error(`body cannot exceed ${TASK_BODY_MAX_LENGTH} characters`);
+		if (input.labels !== undefined) {
+			if (input.labels.length > TASK_LABEL_MAX_COUNT) throw new Error(`labels cannot exceed ${TASK_LABEL_MAX_COUNT} entries`);
+			if (input.labels.some((label) => label.length === 0 || label.length > TASK_LABEL_MAX_LENGTH)) {
+				throw new Error(`each label must be between 1 and ${TASK_LABEL_MAX_LENGTH} characters`);
+			}
+		}
+		return this.events.atomic(() => {
+			this.require(id);
+			const updated = this.artifacts.updateContent(id, input);
+			if (!updated) throw new Error(`task "${id}" not found`);
+			this.appendEvent({ taskId: id, type: "updated", evidence: { result: `fields:${fields.sort().join(",")}` } }, context);
+			return updated;
+		});
+	}
+
 	list(filter: TaskFilter = {}): Artifact[] {
 		const selection = this.scopeSelection(filter.projectRoot, filter.scope, filter.rootTaskId);
 		const limit = filter.limit ?? TASK_SCOPE_MAX_TASKS;
@@ -204,10 +249,12 @@ export class Tasks {
 			throw new Error(`task execution graph exceeds ${TASK_EXECUTION_MAX_NODES} nodes`);
 		}
 		const byId = new Map(tasks.map((task) => [task.id, task]));
-		const focusedId = this.focusStore.get();
+		const focus = this.focusStore.get();
+		const focusedId = focus?.taskId;
 		const nodes = new Map(tasks.map((task) => [task.id, {
 			task,
 			active: task.id === focusedId,
+			...(task.id === focusedId ? { focusStatus: focus!.status } : {}),
 			parentIds: [] as string[],
 			childIds: [] as string[],
 			dependencyIds: [] as string[],
@@ -247,25 +294,60 @@ export class Tasks {
 		return this.artifacts.get(id, { tree: true })!;
 	}
 
-	active(filter?: TaskFilter): Artifact | null {
-		const id = this.focusStore.get();
-		if (!id) return null;
-		const task = this.artifacts.get(id);
+	focused(filter?: TaskFilter): TaskFocus | null {
+		const focus = this.focusStore.get();
+		if (!focus) return null;
+		const task = this.artifacts.get(focus.taskId);
 		if (!task || task.kind !== "task" || task.status === "done" || task.status === "canceled") {
-			this.focusStore.clear(id);
+			this.focusStore.clear(focus.taskId);
 			return null;
 		}
 		if (filter?.projectRoot && !this.list(filter).some((candidate) => candidate.id === task.id)) return null;
-		return task;
+		return { artifact: task, status: focus.status, updatedAt: focus.updatedAt, ...(focus.pauseReason ? { pauseReason: focus.pauseReason } : {}) };
 	}
 
-	focus(id: string): Artifact {
-		const task = this.require(id);
-		if (task.status === "done" || task.status === "canceled") {
-			throw new Error(`cannot focus task from ${task.status}`);
-		}
-		this.focusStore.set(id);
-		return task;
+	active(filter?: TaskFilter): Artifact | null {
+		const focus = this.focused(filter);
+		return focus?.status === "active" ? focus.artifact : null;
+	}
+
+	focus(id: string, context: TaskEventContext = {}): Artifact {
+		return this.events.atomic(() => {
+			const task = this.require(id);
+			if (task.status === "done" || task.status === "canceled") throw new Error(`cannot focus task from ${task.status}`);
+			this.focusStore.set(id);
+			this.appendEvent({ taskId: id, type: "focus_set" }, context);
+			return task;
+		});
+	}
+
+	pauseFocus(context: TaskEventContext = {}): TaskFocus {
+		return this.events.atomic(() => {
+			const focus = this.focused();
+			if (!focus) throw new Error("no focused task");
+			const state = this.focusStore.pause(focus.artifact.id, context.reason);
+			this.appendEvent({ taskId: focus.artifact.id, type: "focus_paused" }, context);
+			return { artifact: focus.artifact, status: state.status, updatedAt: state.updatedAt, ...(state.pauseReason ? { pauseReason: state.pauseReason } : {}) };
+		});
+	}
+
+	unpauseFocus(context: TaskEventContext = {}): TaskFocus {
+		return this.events.atomic(() => {
+			const focus = this.focused();
+			if (!focus) throw new Error("no focused task");
+			const state = this.focusStore.unpause(focus.artifact.id);
+			this.appendEvent({ taskId: focus.artifact.id, type: "focus_unpaused" }, context);
+			return { artifact: focus.artifact, status: state.status, updatedAt: state.updatedAt };
+		});
+	}
+
+	clearFocus(context: TaskEventContext = {}): { cleared: boolean } {
+		return this.events.atomic(() => {
+			const focus = this.focusStore.get();
+			if (focus) this.appendEvent({ taskId: focus.taskId, type: "focus_cleared" }, context);
+			this.focusStore.clear();
+			return { cleared: focus !== undefined };
+		});
 	}
 
 	transition(id: string, action: TaskTransition, context: TaskEventContext = {}): Artifact {
@@ -324,19 +406,6 @@ export class Tasks {
 		return this.artifacts.setExtra(id, { ...task.extra, checklist: validateChecklist(checklist) })!;
 	}
 
-	setAutomation(id: string, enabled: boolean, context: TaskEventContext = {}): Artifact {
-		return this.events.atomic(() => {
-			const task = this.require(id);
-			const current = task.extra["automation"];
-			const automation = typeof current === "object" && current !== null && !Array.isArray(current)
-				? current as Record<string, unknown>
-				: {};
-			const updated = this.artifacts.setExtra(id, { ...task.extra, automation: { ...automation, enabled } })!;
-			this.appendEvent({ taskId: id, type: enabled ? "automation_enabled" : "automation_disabled" }, context);
-			return updated;
-		});
-	}
-
 	depend(id: string, dependencyId: string): Artifact {
 		this.require(id);
 		this.require(dependencyId);

package/src/task-automation.ts

@@ -1,188 +0,0 @@
-import {
-	TASK_AUTOMATION_ERROR_ID_MAX_LENGTH,
-	TASK_AUTOMATION_ERROR_MESSAGE_MAX_LENGTH,
-	TASK_AUTOMATION_GATE_CONCURRENCY,
-	TASK_AUTOMATION_HARD_MAX_RUNTIME_MS,
-	TASK_AUTOMATION_HARD_MAX_TASKS_PER_SWEEP,
-	TASK_AUTOMATION_INTERVAL_MS,
-	TASK_AUTOMATION_MAX_CANDIDATE_SCAN,
-	TASK_AUTOMATION_MAX_GATE_CONCURRENCY,
-	TASK_AUTOMATION_MAX_INTERVAL_MS,
-	TASK_AUTOMATION_MAX_RUNTIME_MS,
-	TASK_AUTOMATION_MAX_TASKS_PER_SWEEP,
-	TASK_AUTOMATION_MIN_INTERVAL_MS,
-} from "./constants.ts";
-import type { Artifact } from "./domain/artifact.ts";
-import { projectTaskExecution } from "./task-execution.ts";
-import type { Tasks } from "./task-service.ts";
-
-export interface TaskAutomationSettings {
-	enabled: boolean;
-	intervalMs: number;
-	maxTasksPerSweep: number;
-	gateConcurrency: number;
-	maxRuntimeMs: number;
-}
-
-export interface TaskAutomationResult {
-	skipped?: "disabled" | "in-flight";
-	examined: number;
-	completed: number;
-	rejected: number;
-	started: number;
-	errors: Array<{ taskId: string; message: string }>;
-	timedOut: boolean;
-}
-
-function boundedInteger(
-	env: Record<string, string | undefined>,
-	name: string,
-	fallback: number,
-	minimum: number,
-	maximum: number,
-): number {
-	const source = env[name];
-	if (source === undefined || source === "") return fallback;
-	const value = Number(source);
-	if (!Number.isInteger(value) || value < minimum || value > maximum) {
-		throw new Error(`${name} must be an integer between ${minimum} and ${maximum}`);
-	}
-	return value;
-}
-
-export function taskAutomationSettings(env: Record<string, string | undefined> = process.env): TaskAutomationSettings {
-	const enabled = env["PAPYRUS_AUTOMATION_ENABLED"] === "1";
-	if (env["PAPYRUS_AUTOMATION_ENABLED"] !== undefined && env["PAPYRUS_AUTOMATION_ENABLED"] !== "0" && !enabled) {
-		throw new Error("PAPYRUS_AUTOMATION_ENABLED must be 0 or 1");
-	}
-	return {
-		enabled,
-		intervalMs: boundedInteger(env, "PAPYRUS_AUTOMATION_INTERVAL_MS", TASK_AUTOMATION_INTERVAL_MS, TASK_AUTOMATION_MIN_INTERVAL_MS, TASK_AUTOMATION_MAX_INTERVAL_MS),
-		maxTasksPerSweep: boundedInteger(env, "PAPYRUS_AUTOMATION_MAX_TASKS", TASK_AUTOMATION_MAX_TASKS_PER_SWEEP, 1, TASK_AUTOMATION_HARD_MAX_TASKS_PER_SWEEP),
-		gateConcurrency: boundedInteger(env, "PAPYRUS_AUTOMATION_GATE_CONCURRENCY", TASK_AUTOMATION_GATE_CONCURRENCY, 1, TASK_AUTOMATION_MAX_GATE_CONCURRENCY),
-		maxRuntimeMs: boundedInteger(env, "PAPYRUS_AUTOMATION_MAX_RUNTIME_MS", TASK_AUTOMATION_MAX_RUNTIME_MS, 1, TASK_AUTOMATION_HARD_MAX_RUNTIME_MS),
-	};
-}
-
-function automationEnabled(task: Artifact): boolean {
-	const automation = task.extra["automation"];
-	return typeof automation === "object"
-		&& automation !== null
-		&& !Array.isArray(automation)
-		&& (automation as Record<string, unknown>)["enabled"] === true;
-}
-
-function emptyResult(skipped?: TaskAutomationResult["skipped"]): TaskAutomationResult {
-	return { ...(skipped ? { skipped } : {}), examined: 0, completed: 0, rejected: 0, started: 0, errors: [], timedOut: false };
-}
-
-function boundedError(taskId: string, error: unknown): TaskAutomationResult["errors"][number] {
-	const message = error instanceof Error ? error.message : String(error);
-	return {
-		taskId: taskId.slice(0, TASK_AUTOMATION_ERROR_ID_MAX_LENGTH),
-		message: message.slice(0, TASK_AUTOMATION_ERROR_MESSAGE_MAX_LENGTH),
-	};
-}
-
-export interface TaskAutomationScheduler {
-	setInterval(callback: () => void, intervalMs: number): unknown;
-	clearInterval(handle: unknown): void;
-}
-
-const SYSTEM_SCHEDULER: TaskAutomationScheduler = {
-	setInterval: (callback, intervalMs) => setInterval(callback, intervalMs),
-	clearInterval: (handle) => clearInterval(handle as ReturnType<typeof setInterval>),
-};
-
-export function scheduleTaskAutomation(
-	settings: TaskAutomationSettings,
-	sweep: () => Promise<unknown>,
-	onError: (error: unknown) => void,
-	scheduler: TaskAutomationScheduler = SYSTEM_SCHEDULER,
-): () => void {
-	if (!settings.enabled) return () => {};
-	const handle = scheduler.setInterval(() => { void sweep().catch(onError); }, settings.intervalMs);
-	return () => scheduler.clearInterval(handle);
-}
-
-export class TaskAutomationReconciler {
-	private inFlight = false;
-
-	constructor(
-		private readonly tasks: Tasks,
-		private readonly settings: TaskAutomationSettings,
-		private readonly now: () => number = () => Date.now(),
-	) {}
-
-	status(): TaskAutomationSettings & { inFlight: boolean } {
-		return { ...this.settings, inFlight: this.inFlight };
-	}
-
-	async reconcile(): Promise<TaskAutomationResult> {
-		if (!this.settings.enabled) return emptyResult("disabled");
-		if (this.inFlight) return emptyResult("in-flight");
-		this.inFlight = true;
-		try { return await this.runSweep(); }
-		finally { this.inFlight = false; }
-	}
-
-	private async runSweep(): Promise<TaskAutomationResult> {
-		const result = emptyResult();
-		const deadline = this.now() + this.settings.maxRuntimeMs;
-		const candidates = this.tasks.list({ status: "review", limit: TASK_AUTOMATION_MAX_CANDIDATE_SCAN })
-			.filter(automationEnabled)
-			.sort((left, right) => left.id.localeCompare(right.id))
-			.slice(0, this.settings.maxTasksPerSweep);
-		const completedIds = new Set<string>();
-
-		for (let offset = 0; offset < candidates.length; offset += this.settings.gateConcurrency) {
-			if (this.now() >= deadline) { result.timedOut = true; break; }
-			const batch = candidates.slice(offset, offset + this.settings.gateConcurrency);
-			await Promise.all(batch.map(async (task) => {
-				result.examined += 1;
-				try {
-					const completion = await this.tasks.completeAsync(task.id, {
-						actor: "daemon",
-						source: "automation-reconciler",
-						reason: "automation-enabled review reconciliation",
-					}, { focusSuccessor: false, gateDeadlineMs: deadline });
-					if (completion.completed) {
-						result.completed += 1;
-						completedIds.add(task.id);
-					} else result.rejected += 1;
-				} catch (error) {
-					result.errors.push(boundedError(task.id, error));
-				}
-			}));
-		}
-
-		let remaining = Math.max(0, this.settings.maxTasksPerSweep - result.examined);
-		if (remaining > 0 && completedIds.size > 0 && this.now() < deadline) {
-			let graph: ReturnType<Tasks["graph"]>;
-			try { graph = this.tasks.graph(); }
-			catch (error) {
-				result.errors.push(boundedError("graph", error));
-				return result;
-			}
-			const stateById = new Map(projectTaskExecution(graph).nodes.map((node) => [node.id, node.state]));
-			for (const node of [...graph.nodes].sort((left, right) => left.task.id.localeCompare(right.task.id))) {
-				if (remaining === 0 || this.now() >= deadline) break;
-				if (node.task.status !== "todo" || !automationEnabled(node.task) || stateById.get(node.task.id) !== "ready") continue;
-				if (!node.dependencyIds.some((id) => completedIds.has(id))) continue;
-				try {
-					this.tasks.transition(node.task.id, "start", {
-						actor: "daemon",
-						source: "automation-reconciler",
-						reason: "automation-enabled successor became ready",
-					});
-					result.started += 1;
-					remaining -= 1;
-				} catch (error) {
-					result.errors.push(boundedError(node.task.id, error));
-				}
-			}
-		}
-		if (this.now() >= deadline) result.timedOut = true;
-		return result;
-	}
-}