@vibescope/mcp-server 0.0.1 → 0.2.0

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

@@ -14,35 +14,38 @@
  * - remove_task_dependency
  * - get_task_dependencies
  * - get_next_body_of_work_task
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
 import { validateRequired, validateUUID } from '../validators.js';
+import { getApiClient } from '../api-client.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({
+    const { session } = ctx;
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('create_body_of_work', {
         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}`);
+        description,
+        auto_deploy_on_completion,
+        deploy_environment,
+        deploy_version_bump,
+        deploy_trigger
+    }, {
+        session_id: session.currentSessionId,
+        persona: session.currentPersona,
+        instance_id: session.instanceId
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to create body of work: ${response.error}`);
+    }
     return {
         result: {
             success: true,
-            body_of_work_id: data.id,
+            body_of_work_id: response.data?.body_of_work_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.',
@@ -53,172 +56,66 @@ 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) {
+    // Check if any updates provided
+    if (title === undefined && description === undefined && auto_deploy_on_completion === undefined &&
+        deploy_environment === undefined && deploy_version_bump === undefined && deploy_trigger === undefined) {
         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}`);
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('update_body_of_work', {
+        body_of_work_id,
+        title,
+        description,
+        auto_deploy_on_completion,
+        deploy_environment,
+        deploy_version_bump,
+        deploy_trigger
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to update body of work: ${response.error}`);
+    }
     return { result: { success: true, body_of_work_id } };
 };
 export const getBodyOfWork = async (args, ctx) => {
-    const { body_of_work_id } = args;
+    const { body_of_work_id, summary_only = false } = 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}`);
+    const apiClient = getApiClient();
+    // Response type varies based on summary_only
+    const response = await apiClient.proxy('get_body_of_work', { body_of_work_id, summary_only });
+    if (!response.ok) {
+        throw new Error(`Failed to get body of work: ${response.error}`);
     }
-    // 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,
-        },
-    };
+    return { result: response.data };
 };
 export const getBodiesOfWork = async (args, ctx) => {
-    const { project_id, status } = args;
+    const { project_id, status, limit = 50, offset = 0, search_query } = 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,
-        };
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('get_bodies_of_work', {
+        project_id,
+        status,
+        limit: Math.min(limit, 100),
+        offset,
+        search_query
     });
-    return { result: { bodies_of_work: bodiesWithCounts } };
+    if (!response.ok) {
+        throw new Error(`Failed to fetch bodies of work: ${response.error}`);
+    }
+    return { result: response.data };
 };
 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}`);
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('delete_body_of_work', {
+        body_of_work_id
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to delete body of work: ${response.error}`);
+    }
     return { result: { success: true, message: 'Body of work deleted. Tasks are preserved.' } };
 };
 export const addTaskToBodyOfWork = async (args, ctx) => {
@@ -227,136 +124,39 @@ export const addTaskToBodyOfWork = async (args, ctx) => {
     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({
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('add_task_to_body_of_work', {
         body_of_work_id,
         task_id,
-        phase: taskPhase,
-        order_index: finalOrderIndex,
+        phase: phase || 'core',
+        order_index
     });
-    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,
-        },
-    };
+    if (!response.ok) {
+        throw new Error(`Failed to add task to body of work: ${response.error}`);
+    }
+    return { result: response.data };
 };
 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 apiClient = getApiClient();
+    const response = await apiClient.proxy('remove_task_from_body_of_work', { task_id });
+    if (!response.ok) {
+        throw new Error(`Failed to remove task from body of work: ${response.error}`);
     }
-    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 } };
+    return { result: response.data };
 };
 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}`);
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('activate_body_of_work', { body_of_work_id });
+    if (!response.ok) {
+        throw new Error(`Failed to activate body of work: ${response.error}`);
     }
-    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.',
-        },
-    };
+    return { result: response.data };
 };
 export const addTaskDependency = async (args, ctx) => {
     const { body_of_work_id, task_id, depends_on_task_id } = args;
@@ -369,63 +169,16 @@ export const addTaskDependency = async (args, ctx) => {
     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({
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('add_task_dependency', {
         body_of_work_id,
         task_id,
-        depends_on_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}`);
+    if (!response.ok) {
+        throw new Error(`Failed to add task dependency: ${response.error}`);
     }
-    return {
-        result: {
-            success: true,
-            body_of_work_id,
-            task_id,
-            depends_on_task_id,
-            message: `Task now depends on completion of the specified task`,
-        },
-    };
+    return { result: response.data };
 };
 export const removeTaskDependency = async (args, ctx) => {
     const { task_id, depends_on_task_id } = args;
@@ -433,15 +186,15 @@ export const removeTaskDependency = async (args, ctx) => {
     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 } };
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('remove_task_dependency', {
+        task_id,
+        depends_on_task_id
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to remove task dependency: ${response.error}`);
+    }
+    return { result: response.data };
 };
 export const getTaskDependencies = async (args, ctx) => {
     const { body_of_work_id, task_id } = args;
@@ -452,148 +205,26 @@ export const getTaskDependencies = async (args, ctx) => {
         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 apiClient = getApiClient();
+    const response = await apiClient.proxy('get_task_dependencies', {
+        body_of_work_id,
+        task_id
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch task dependencies: ${response.error}`);
     }
-    const { data, error } = await query;
-    if (error)
-        throw new Error(`Failed to fetch dependencies: ${error.message}`);
-    return { result: { dependencies: data || [] } };
+    return { result: response.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);
-        }
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('get_next_body_of_work_task', { body_of_work_id });
+    if (!response.ok) {
+        throw new Error(`Failed to get next body of work task: ${response.error}`);
     }
-    // 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',
-        },
-    };
+    return { result: response.data };
 };
 /**
  * Bodies of Work handlers registry