@vibescope/mcp-server 0.0.1

package/src/handlers/bodies-of-work.ts

@@ -0,0 +1,783 @@
+/**
+ * Bodies of Work Handlers
+ *
+ * Handles grouping tasks into bodies of work with phases:
+ * - create_body_of_work
+ * - update_body_of_work
+ * - get_body_of_work
+ * - get_bodies_of_work
+ * - delete_body_of_work
+ * - add_task_to_body_of_work
+ * - remove_task_from_body_of_work
+ * - activate_body_of_work
+ * - add_task_dependency
+ * - remove_task_dependency
+ * - get_task_dependencies
+ * - get_next_body_of_work_task
+ */
+
+import type { Handler, HandlerRegistry } from './types.js';
+import { validateRequired, validateUUID } from '../validators.js';
+
+type BodyOfWorkStatus = 'draft' | 'active' | 'completed' | 'cancelled';
+type TaskPhase = 'pre' | 'core' | 'post';
+type DeployEnvironment = 'development' | 'staging' | 'production';
+type VersionBump = 'patch' | 'minor' | 'major';
+type DeployTrigger = 'all_completed' | 'all_completed_validated';
+
+export const createBodyOfWork: Handler = async (args, ctx) => {
+	const {
+		project_id,
+		title,
+		description,
+		auto_deploy_on_completion,
+		deploy_environment,
+		deploy_version_bump,
+		deploy_trigger,
+	} = args as {
+		project_id: string;
+		title: string;
+		description?: string;
+		auto_deploy_on_completion?: boolean;
+		deploy_environment?: DeployEnvironment;
+		deploy_version_bump?: VersionBump;
+		deploy_trigger?: DeployTrigger;
+	};
+
+	validateRequired(project_id, 'project_id');
+	validateUUID(project_id, 'project_id');
+	validateRequired(title, 'title');
+
+	const { supabase, session } = ctx;
+
+	const { data, error } = await supabase
+		.from('bodies_of_work')
+		.insert({
+			project_id,
+			title,
+			description: description || null,
+			auto_deploy_on_completion: auto_deploy_on_completion || false,
+			deploy_environment: deploy_environment || 'production',
+			deploy_version_bump: deploy_version_bump || 'minor',
+			deploy_trigger: deploy_trigger || 'all_completed_validated',
+			created_by: 'agent',
+			created_by_session_id: session.currentSessionId,
+		})
+		.select('id')
+		.single();
+
+	if (error) throw new Error(`Failed to create body of work: ${error.message}`);
+
+	return {
+		result: {
+			success: true,
+			body_of_work_id: data.id,
+			title,
+			status: 'draft',
+			message: 'Body of work created. Add tasks with add_task_to_body_of_work, then activate with activate_body_of_work.',
+		},
+	};
+};
+
+export const updateBodyOfWork: Handler = async (args, ctx) => {
+	const {
+		body_of_work_id,
+		title,
+		description,
+		auto_deploy_on_completion,
+		deploy_environment,
+		deploy_version_bump,
+		deploy_trigger,
+	} = args as {
+		body_of_work_id: string;
+		title?: string;
+		description?: string;
+		auto_deploy_on_completion?: boolean;
+		deploy_environment?: DeployEnvironment;
+		deploy_version_bump?: VersionBump;
+		deploy_trigger?: DeployTrigger;
+	};
+
+	validateRequired(body_of_work_id, 'body_of_work_id');
+	validateUUID(body_of_work_id, 'body_of_work_id');
+
+	const { supabase } = ctx;
+
+	// Build update object
+	const updates: Record<string, unknown> = {};
+	if (title !== undefined) updates.title = title;
+	if (description !== undefined) updates.description = description;
+	if (auto_deploy_on_completion !== undefined) updates.auto_deploy_on_completion = auto_deploy_on_completion;
+	if (deploy_environment !== undefined) updates.deploy_environment = deploy_environment;
+	if (deploy_version_bump !== undefined) updates.deploy_version_bump = deploy_version_bump;
+	if (deploy_trigger !== undefined) updates.deploy_trigger = deploy_trigger;
+
+	if (Object.keys(updates).length === 0) {
+		return { result: { success: true, message: 'No updates provided' } };
+	}
+
+	const { error } = await supabase
+		.from('bodies_of_work')
+		.update(updates)
+		.eq('id', body_of_work_id);
+
+	if (error) throw new Error(`Failed to update body of work: ${error.message}`);
+
+	return { result: { success: true, body_of_work_id } };
+};
+
+export const getBodyOfWork: Handler = async (args, ctx) => {
+	const { body_of_work_id } = args as { body_of_work_id: string };
+
+	validateRequired(body_of_work_id, 'body_of_work_id');
+	validateUUID(body_of_work_id, 'body_of_work_id');
+
+	const { supabase } = ctx;
+
+	// Get body of work
+	const { data: bow, error: bowError } = await supabase
+		.from('bodies_of_work')
+		.select('*')
+		.eq('id', body_of_work_id)
+		.single();
+
+	if (bowError || !bow) {
+		throw new Error(`Body of work not found: ${body_of_work_id}`);
+	}
+
+	// Get tasks with their phases
+	const { data: taskLinks, error: taskError } = await supabase
+		.from('body_of_work_tasks')
+		.select(`
+			phase,
+			order_index,
+			tasks (
+				id,
+				title,
+				status,
+				priority,
+				progress_percentage
+			)
+		`)
+		.eq('body_of_work_id', body_of_work_id)
+		.order('order_index');
+
+	if (taskError) throw new Error(`Failed to fetch tasks: ${taskError.message}`);
+
+	// Organize tasks by phase
+	const preTasks: unknown[] = [];
+	const coreTasks: unknown[] = [];
+	const postTasks: unknown[] = [];
+
+	for (const link of taskLinks || []) {
+		const task = link.tasks;
+		if (!task) continue;
+
+		const taskWithPhase = { ...task, order_index: link.order_index };
+
+		switch (link.phase) {
+			case 'pre':
+				preTasks.push(taskWithPhase);
+				break;
+			case 'core':
+				coreTasks.push(taskWithPhase);
+				break;
+			case 'post':
+				postTasks.push(taskWithPhase);
+				break;
+		}
+	}
+
+	return {
+		result: {
+			...bow,
+			pre_tasks: preTasks,
+			core_tasks: coreTasks,
+			post_tasks: postTasks,
+			total_tasks: preTasks.length + coreTasks.length + postTasks.length,
+		},
+	};
+};
+
+export const getBodiesOfWork: Handler = async (args, ctx) => {
+	const { project_id, status } = args as {
+		project_id: string;
+		status?: BodyOfWorkStatus;
+	};
+
+	validateRequired(project_id, 'project_id');
+	validateUUID(project_id, 'project_id');
+
+	const { supabase } = ctx;
+
+	let query = supabase
+		.from('bodies_of_work')
+		.select(`
+			id,
+			title,
+			description,
+			status,
+			progress_percentage,
+			auto_deploy_on_completion,
+			deploy_environment,
+			deploy_version_bump,
+			created_at,
+			activated_at,
+			completed_at
+		`)
+		.eq('project_id', project_id);
+
+	if (status) {
+		query = query.eq('status', status);
+	}
+
+	const { data, error } = await query.order('created_at', { ascending: false });
+
+	if (error) throw new Error(`Failed to fetch bodies of work: ${error.message}`);
+
+	const bodies = data || [];
+	if (bodies.length === 0) {
+		return { result: { bodies_of_work: [] } };
+	}
+
+	// Batch query: get all task links for all bodies of work in a single query
+	const bodyIds = bodies.map((b) => b.id);
+	const { data: allTaskLinks } = await supabase
+		.from('body_of_work_tasks')
+		.select('body_of_work_id, phase, tasks!inner(status)')
+		.in('body_of_work_id', bodyIds);
+
+	// Group task links by body_of_work_id
+	const taskLinksByBody = new Map<string, typeof allTaskLinks>();
+	for (const link of allTaskLinks || []) {
+		const existing = taskLinksByBody.get(link.body_of_work_id) || [];
+		existing.push(link);
+		taskLinksByBody.set(link.body_of_work_id, existing);
+	}
+
+	// Build response with task counts
+	const bodiesWithCounts = bodies.map((bow) => {
+		const taskLinks = taskLinksByBody.get(bow.id) || [];
+		const taskCounts = {
+			pre: { total: 0, completed: 0 },
+			core: { total: 0, completed: 0 },
+			post: { total: 0, completed: 0 },
+		};
+
+		for (const link of taskLinks) {
+			const phase = link.phase as TaskPhase;
+			taskCounts[phase].total++;
+			const taskData = link.tasks as unknown as { status: string } | null;
+			if (taskData?.status === 'completed') {
+				taskCounts[phase].completed++;
+			}
+		}
+
+		return {
+			...bow,
+			task_counts: taskCounts,
+		};
+	});
+
+	return { result: { bodies_of_work: bodiesWithCounts } };
+};
+
+export const deleteBodyOfWork: Handler = async (args, ctx) => {
+	const { body_of_work_id } = args as { body_of_work_id: string };
+
+	validateRequired(body_of_work_id, 'body_of_work_id');
+	validateUUID(body_of_work_id, 'body_of_work_id');
+
+	const { error } = await ctx.supabase
+		.from('bodies_of_work')
+		.delete()
+		.eq('id', body_of_work_id);
+
+	if (error) throw new Error(`Failed to delete body of work: ${error.message}`);
+
+	return { result: { success: true, message: 'Body of work deleted. Tasks are preserved.' } };
+};
+
+export const addTaskToBodyOfWork: Handler = async (args, ctx) => {
+	const { body_of_work_id, task_id, phase, order_index } = args as {
+		body_of_work_id: string;
+		task_id: string;
+		phase?: TaskPhase;
+		order_index?: number;
+	};
+
+	validateRequired(body_of_work_id, 'body_of_work_id');
+	validateUUID(body_of_work_id, 'body_of_work_id');
+	validateRequired(task_id, 'task_id');
+	validateUUID(task_id, 'task_id');
+
+	const { supabase } = ctx;
+	const taskPhase = phase || 'core';
+
+	// Check if body of work exists and is in draft/active status
+	const { data: bow, error: bowError } = await supabase
+		.from('bodies_of_work')
+		.select('status')
+		.eq('id', body_of_work_id)
+		.single();
+
+	if (bowError || !bow) {
+		throw new Error(`Body of work not found: ${body_of_work_id}`);
+	}
+
+	if (bow.status === 'completed' || bow.status === 'cancelled') {
+		throw new Error(`Cannot add tasks to ${bow.status} body of work`);
+	}
+
+	// Check if task is already in a body of work
+	const { data: existingLink } = await supabase
+		.from('body_of_work_tasks')
+		.select('body_of_work_id')
+		.eq('task_id', task_id)
+		.single();
+
+	if (existingLink) {
+		throw new Error('Task is already assigned to a body of work. Remove it first.');
+	}
+
+	// Get the next order index if not provided
+	let finalOrderIndex = order_index;
+	if (finalOrderIndex === undefined) {
+		const { data: maxOrder } = await supabase
+			.from('body_of_work_tasks')
+			.select('order_index')
+			.eq('body_of_work_id', body_of_work_id)
+			.eq('phase', taskPhase)
+			.order('order_index', { ascending: false })
+			.limit(1)
+			.single();
+
+		finalOrderIndex = maxOrder ? maxOrder.order_index + 1 : 0;
+	}
+
+	const { error } = await supabase
+		.from('body_of_work_tasks')
+		.insert({
+			body_of_work_id,
+			task_id,
+			phase: taskPhase,
+			order_index: finalOrderIndex,
+		});
+
+	if (error) throw new Error(`Failed to add task to body of work: ${error.message}`);
+
+	return {
+		result: {
+			success: true,
+			body_of_work_id,
+			task_id,
+			phase: taskPhase,
+			order_index: finalOrderIndex,
+		},
+	};
+};
+
+export const removeTaskFromBodyOfWork: Handler = async (args, ctx) => {
+	const { task_id } = args as { task_id: string };
+
+	validateRequired(task_id, 'task_id');
+	validateUUID(task_id, 'task_id');
+
+	const { supabase } = ctx;
+
+	// Check if link exists
+	const { data: link } = await supabase
+		.from('body_of_work_tasks')
+		.select('body_of_work_id')
+		.eq('task_id', task_id)
+		.single();
+
+	if (!link) {
+		return { result: { success: true, message: 'Task is not in any body of work' } };
+	}
+
+	// Check if body of work is completed
+	const { data: bow } = await supabase
+		.from('bodies_of_work')
+		.select('status')
+		.eq('id', link.body_of_work_id)
+		.single();
+
+	if (bow?.status === 'completed') {
+		throw new Error('Cannot remove tasks from a completed body of work');
+	}
+
+	const { error } = await supabase
+		.from('body_of_work_tasks')
+		.delete()
+		.eq('task_id', task_id);
+
+	if (error) throw new Error(`Failed to remove task from body of work: ${error.message}`);
+
+	return { result: { success: true, body_of_work_id: link.body_of_work_id } };
+};
+
+export const activateBodyOfWork: Handler = async (args, ctx) => {
+	const { body_of_work_id } = args as { body_of_work_id: string };
+
+	validateRequired(body_of_work_id, 'body_of_work_id');
+	validateUUID(body_of_work_id, 'body_of_work_id');
+
+	const { supabase } = ctx;
+
+	// Check current status
+	const { data: bow, error: bowError } = await supabase
+		.from('bodies_of_work')
+		.select('status, title')
+		.eq('id', body_of_work_id)
+		.single();
+
+	if (bowError || !bow) {
+		throw new Error(`Body of work not found: ${body_of_work_id}`);
+	}
+
+	if (bow.status !== 'draft') {
+		throw new Error(`Can only activate draft bodies of work. Current status: ${bow.status}`);
+	}
+
+	// Check if there are any tasks
+	const { count } = await supabase
+		.from('body_of_work_tasks')
+		.select('id', { count: 'exact', head: true })
+		.eq('body_of_work_id', body_of_work_id);
+
+	if (!count || count === 0) {
+		throw new Error('Cannot activate body of work with no tasks. Add tasks first.');
+	}
+
+	const { error } = await supabase
+		.from('bodies_of_work')
+		.update({
+			status: 'active',
+			activated_at: new Date().toISOString(),
+		})
+		.eq('id', body_of_work_id);
+
+	if (error) throw new Error(`Failed to activate body of work: ${error.message}`);
+
+	return {
+		result: {
+			success: true,
+			body_of_work_id,
+			title: bow.title,
+			status: 'active',
+			message: 'Body of work activated. Tasks can now be worked on following phase order.',
+		},
+	};
+};
+
+export const addTaskDependency: Handler = async (args, ctx) => {
+	const { body_of_work_id, task_id, depends_on_task_id } = args as {
+		body_of_work_id: string;
+		task_id: string;
+		depends_on_task_id: string;
+	};
+
+	validateRequired(body_of_work_id, 'body_of_work_id');
+	validateUUID(body_of_work_id, 'body_of_work_id');
+	validateRequired(task_id, 'task_id');
+	validateUUID(task_id, 'task_id');
+	validateRequired(depends_on_task_id, 'depends_on_task_id');
+	validateUUID(depends_on_task_id, 'depends_on_task_id');
+
+	if (task_id === depends_on_task_id) {
+		throw new Error('A task cannot depend on itself');
+	}
+
+	const { supabase } = ctx;
+
+	// Verify both tasks belong to the same body of work
+	const { data: taskLinks, error: taskError } = await supabase
+		.from('body_of_work_tasks')
+		.select('task_id')
+		.eq('body_of_work_id', body_of_work_id)
+		.in('task_id', [task_id, depends_on_task_id]);
+
+	if (taskError) throw new Error(`Failed to verify tasks: ${taskError.message}`);
+
+	if (!taskLinks || taskLinks.length !== 2) {
+		throw new Error('Both tasks must belong to the specified body of work');
+	}
+
+	// Check for circular dependencies by traversing the dependency graph
+	const visited = new Set<string>();
+	const checkCircular = async (currentTaskId: string): Promise<boolean> => {
+		if (currentTaskId === task_id) return true; // Found cycle
+		if (visited.has(currentTaskId)) return false;
+		visited.add(currentTaskId);
+
+		const { data: deps } = await supabase
+			.from('body_of_work_task_dependencies')
+			.select('depends_on_task_id')
+			.eq('task_id', currentTaskId)
+			.eq('body_of_work_id', body_of_work_id);
+
+		for (const dep of deps || []) {
+			if (await checkCircular(dep.depends_on_task_id)) {
+				return true;
+			}
+		}
+		return false;
+	};
+
+	if (await checkCircular(depends_on_task_id)) {
+		throw new Error('Cannot add dependency: would create a circular dependency');
+	}
+
+	const { error } = await supabase
+		.from('body_of_work_task_dependencies')
+		.insert({
+			body_of_work_id,
+			task_id,
+			depends_on_task_id,
+		});
+
+	if (error) {
+		if (error.message.includes('duplicate')) {
+			throw new Error('This dependency already exists');
+		}
+		throw new Error(`Failed to add dependency: ${error.message}`);
+	}
+
+	return {
+		result: {
+			success: true,
+			body_of_work_id,
+			task_id,
+			depends_on_task_id,
+			message: `Task now depends on completion of the specified task`,
+		},
+	};
+};
+
+export const removeTaskDependency: Handler = async (args, ctx) => {
+	const { task_id, depends_on_task_id } = args as {
+		task_id: string;
+		depends_on_task_id: string;
+	};
+
+	validateRequired(task_id, 'task_id');
+	validateUUID(task_id, 'task_id');
+	validateRequired(depends_on_task_id, 'depends_on_task_id');
+	validateUUID(depends_on_task_id, 'depends_on_task_id');
+
+	const { supabase } = ctx;
+
+	const { error } = await supabase
+		.from('body_of_work_task_dependencies')
+		.delete()
+		.eq('task_id', task_id)
+		.eq('depends_on_task_id', depends_on_task_id);
+
+	if (error) throw new Error(`Failed to remove dependency: ${error.message}`);
+
+	return { result: { success: true, task_id, depends_on_task_id } };
+};
+
+export const getTaskDependencies: Handler = async (args, ctx) => {
+	const { body_of_work_id, task_id } = args as {
+		body_of_work_id?: string;
+		task_id?: string;
+	};
+
+	if (!body_of_work_id && !task_id) {
+		throw new Error('Either body_of_work_id or task_id is required');
+	}
+
+	if (body_of_work_id) validateUUID(body_of_work_id, 'body_of_work_id');
+	if (task_id) validateUUID(task_id, 'task_id');
+
+	const { supabase } = ctx;
+
+	let query = supabase
+		.from('body_of_work_task_dependencies')
+		.select(`
+			id,
+			task_id,
+			depends_on_task_id,
+			created_at
+		`);
+
+	if (body_of_work_id) {
+		query = query.eq('body_of_work_id', body_of_work_id);
+	}
+	if (task_id) {
+		query = query.eq('task_id', task_id);
+	}
+
+	const { data, error } = await query;
+
+	if (error) throw new Error(`Failed to fetch dependencies: ${error.message}`);
+
+	return { result: { dependencies: data || [] } };
+};
+
+export const getNextBodyOfWorkTask: Handler = async (args, ctx) => {
+	const { body_of_work_id } = args as { body_of_work_id: string };
+
+	validateRequired(body_of_work_id, 'body_of_work_id');
+	validateUUID(body_of_work_id, 'body_of_work_id');
+
+	const { supabase } = ctx;
+
+	// Get body of work status
+	const { data: bow, error: bowError } = await supabase
+		.from('bodies_of_work')
+		.select('status, title')
+		.eq('id', body_of_work_id)
+		.single();
+
+	if (bowError || !bow) {
+		throw new Error(`Body of work not found: ${body_of_work_id}`);
+	}
+
+	if (bow.status !== 'active') {
+		return {
+			result: {
+				next_task: null,
+				message: `Body of work is ${bow.status}, not active`,
+			},
+		};
+	}
+
+	// Get all tasks with their status and phase
+	const { data: taskLinks, error: taskError } = await supabase
+		.from('body_of_work_tasks')
+		.select(`
+			task_id,
+			phase,
+			order_index,
+			tasks (
+				id,
+				title,
+				status,
+				priority,
+				claimed_by_session_id
+			)
+		`)
+		.eq('body_of_work_id', body_of_work_id)
+		.order('order_index');
+
+	if (taskError) throw new Error(`Failed to fetch tasks: ${taskError.message}`);
+
+	// Get all dependencies
+	const { data: dependencies } = await supabase
+		.from('body_of_work_task_dependencies')
+		.select('task_id, depends_on_task_id')
+		.eq('body_of_work_id', body_of_work_id);
+
+	const depMap = new Map<string, string[]>();
+	for (const dep of dependencies || []) {
+		const existing = depMap.get(dep.task_id) || [];
+		existing.push(dep.depends_on_task_id);
+		depMap.set(dep.task_id, existing);
+	}
+
+	// Build task status map
+	const taskStatusMap = new Map<string, string>();
+	for (const link of taskLinks || []) {
+		const task = link.tasks as unknown as { id: string; status: string } | null;
+		if (task) {
+			taskStatusMap.set(task.id, task.status);
+		}
+	}
+
+	// Check if all dependencies are completed
+	const areDependenciesComplete = (taskId: string): boolean => {
+		const deps = depMap.get(taskId) || [];
+		return deps.every((depId) => taskStatusMap.get(depId) === 'completed');
+	};
+
+	// Phase order: pre -> core -> post
+	const phaseOrder = ['pre', 'core', 'post'];
+
+	// Check if all tasks in a phase are completed
+	const isPhaseComplete = (phase: string): boolean => {
+		return (taskLinks || [])
+			.filter((link) => link.phase === phase)
+			.every((link) => {
+				const task = link.tasks as unknown as { status: string } | null;
+				return task?.status === 'completed';
+			});
+	};
+
+	// Find the next available task
+	for (const phase of phaseOrder) {
+		// Check if we can work on this phase
+		const prevPhaseIndex = phaseOrder.indexOf(phase) - 1;
+		if (prevPhaseIndex >= 0 && !isPhaseComplete(phaseOrder[prevPhaseIndex])) {
+			continue; // Previous phase not complete, skip this phase
+		}
+
+		const phaseTasks = (taskLinks || [])
+			.filter((link) => link.phase === phase)
+			.sort((a, b) => a.order_index - b.order_index);
+
+		for (const link of phaseTasks) {
+			const task = link.tasks as unknown as {
+				id: string;
+				title: string;
+				status: string;
+				priority: number;
+				claimed_by_session_id: string | null;
+			} | null;
+
+			if (!task) continue;
+
+			// Skip completed, cancelled, or in-progress tasks
+			if (task.status !== 'pending') continue;
+
+			// Skip tasks claimed by another session
+			if (task.claimed_by_session_id) continue;
+
+			// Check dependencies
+			if (!areDependenciesComplete(task.id)) continue;
+
+			return {
+				result: {
+					next_task: {
+						id: task.id,
+						title: task.title,
+						phase: link.phase,
+						priority: task.priority,
+					},
+					body_of_work: {
+						id: body_of_work_id,
+						title: bow.title,
+					},
+				},
+			};
+		}
+	}
+
+	// No available tasks
+	return {
+		result: {
+			next_task: null,
+			message: 'No available tasks - all are completed, in progress, or blocked by dependencies',
+		},
+	};
+};
+
+/**
+ * Bodies of Work handlers registry
+ */
+export const bodiesOfWorkHandlers: HandlerRegistry = {
+	create_body_of_work: createBodyOfWork,
+	update_body_of_work: updateBodyOfWork,
+	get_body_of_work: getBodyOfWork,
+	get_bodies_of_work: getBodiesOfWork,
+	delete_body_of_work: deleteBodyOfWork,
+	add_task_to_body_of_work: addTaskToBodyOfWork,
+	remove_task_from_body_of_work: removeTaskFromBodyOfWork,
+	activate_body_of_work: activateBodyOfWork,
+	add_task_dependency: addTaskDependency,
+	remove_task_dependency: removeTaskDependency,
+	get_task_dependencies: getTaskDependencies,
+	get_next_body_of_work_task: getNextBodyOfWorkTask,
+};