@vibescope/mcp-server 0.0.1

package/dist/handlers/bodies-of-work.js

@@ -0,0 +1,614 @@
+/**
+ * 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 { validateRequired, validateUUID } from '../validators.js';
+export const createBodyOfWork = async (args, ctx) => {
+    const { project_id, title, description, auto_deploy_on_completion, deploy_environment, deploy_version_bump, deploy_trigger, } = args;
+    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 = async (args, ctx) => {
+    const { body_of_work_id, title, description, auto_deploy_on_completion, deploy_environment, deploy_version_bump, deploy_trigger, } = args;
+    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 = {};
+    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 = async (args, ctx) => {
+    const { body_of_work_id } = args;
+    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 = [];
+    const coreTasks = [];
+    const postTasks = [];
+    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 = async (args, ctx) => {
+    const { project_id, status } = args;
+    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();
+    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;
+            taskCounts[phase].total++;
+            const taskData = link.tasks;
+            if (taskData?.status === 'completed') {
+                taskCounts[phase].completed++;
+            }
+        }
+        return {
+            ...bow,
+            task_counts: taskCounts,
+        };
+    });
+    return { result: { bodies_of_work: bodiesWithCounts } };
+};
+export const deleteBodyOfWork = async (args, ctx) => {
+    const { body_of_work_id } = args;
+    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 = async (args, ctx) => {
+    const { body_of_work_id, task_id, phase, order_index } = args;
+    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 = async (args, ctx) => {
+    const { task_id } = args;
+    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 = async (args, ctx) => {
+    const { body_of_work_id } = args;
+    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 = async (args, ctx) => {
+    const { body_of_work_id, task_id, depends_on_task_id } = args;
+    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();
+    const checkCircular = async (currentTaskId) => {
+        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 = async (args, ctx) => {
+    const { task_id, depends_on_task_id } = args;
+    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 = async (args, ctx) => {
+    const { body_of_work_id, task_id } = args;
+    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 = async (args, ctx) => {
+    const { body_of_work_id } = args;
+    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();
+    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();
+    for (const link of taskLinks || []) {
+        const task = link.tasks;
+        if (task) {
+            taskStatusMap.set(task.id, task.status);
+        }
+    }
+    // Check if all dependencies are completed
+    const areDependenciesComplete = (taskId) => {
+        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) => {
+        return (taskLinks || [])
+            .filter((link) => link.phase === phase)
+            .every((link) => {
+            const task = link.tasks;
+            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;
+            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 = {
+    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,
+};

package/dist/handlers/checkouts.d.ts

@@ -0,0 +1,37 @@
+/**
+ * File Checkout Handlers
+ *
+ * Handles file checkout/checkin for multi-agent coordination:
+ * - checkout_file: Reserve a file for editing
+ * - checkin_file: Release a file after editing
+ * - get_file_checkouts: List active and recent checkouts
+ * - abandon_checkout: Force-release a checkout
+ */
+import type { Handler, HandlerRegistry } from './types.js';
+/**
+ * Checkout a file for editing
+ * Prevents other agents from editing the same file
+ */
+export declare const checkoutFile: Handler;
+/**
+ * Checkin a file after editing
+ * Releases the file for other agents to edit
+ */
+export declare const checkinFile: Handler;
+/**
+ * Get file checkouts for a project
+ */
+export declare const getFileCheckouts: Handler;
+/**
+ * Abandon a checkout (force release)
+ * Use when the original agent session died or is stuck
+ */
+export declare const abandonCheckout: Handler;
+/**
+ * Check if a file is available for checkout
+ */
+export declare const isFileAvailable: Handler;
+/**
+ * Checkout handlers registry
+ */
+export declare const checkoutHandlers: HandlerRegistry;