@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/fallback.ts

@@ -6,11 +6,14 @@
  * - stop_fallback_activity
  * - get_activity_history
  * - get_activity_schedules
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
 import { validateRequired, validateUUID } from '../validators.js';
 import { FALLBACK_ACTIVITIES } from '../utils.js';
+import { getApiClient } from '../api-client.js';
 
 const VALID_ACTIVITIES = [
 	'feature_ideation',
@@ -36,35 +39,39 @@ export const startFallbackActivity: Handler = async (args, ctx) => {
 		throw new Error(`Invalid activity. Must be one of: ${VALID_ACTIVITIES.join(', ')}`);
 	}
 
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
+	const { session } = ctx;
+	const apiClient = getApiClient();
 
-	// Update the current session's fallback activity
-	const { error: updateError } = await supabase
-		.from('agent_sessions')
-		.update({
-			current_fallback_activity: activity,
-			current_task_id: null, // Clear any task when starting fallback
-			status: 'active',
-			last_synced_at: new Date().toISOString(),
-		})
-		.eq('id', currentSessionId);
+	const response = await apiClient.startFallbackActivity(project_id, activity, session.currentSessionId || undefined);
 
-	if (updateError) throw updateError;
+	if (!response.ok) {
+		throw new Error(`Failed to start fallback activity: ${response.error}`);
+	}
 
 	// Get the activity details for the response
 	const activityInfo = FALLBACK_ACTIVITIES.find((a) => a.activity === activity);
 
-	return {
-		result: {
-			success: true,
-			activity,
-			title: activityInfo?.title || activity,
-			description: activityInfo?.description || '',
-			prompt: activityInfo?.prompt || '',
-			message: `Started fallback activity: ${activityInfo?.title || activity}`,
-		},
+	const result: Record<string, unknown> = {
+		success: true,
+		activity,
+		title: activityInfo?.title || activity,
+		description: activityInfo?.description || '',
+		prompt: activityInfo?.prompt || '',
+		message: response.data?.message || `Started fallback activity: ${activityInfo?.title || activity}`,
 	};
+
+	// Pass through worktree guidance if provided
+	if (response.data?.git_workflow) {
+		result.git_workflow = response.data.git_workflow;
+	}
+	if (response.data?.worktree_setup) {
+		result.worktree_setup = response.data.worktree_setup;
+	}
+	if (response.data?.next_step) {
+		result.next_step = response.data.next_step;
+	}
+
+	return { result };
 };
 
 export const stopFallbackActivity: Handler = async (args, ctx) => {
@@ -73,91 +80,19 @@ export const stopFallbackActivity: Handler = async (args, ctx) => {
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
-
-	// Get the current session's fallback activity before clearing it
-	const { data: sessionData, error: sessionError } = await supabase
-		.from('agent_sessions')
-		.select('current_fallback_activity')
-		.eq('id', currentSessionId)
-		.single();
-
-	if (sessionError) throw sessionError;
-
-	const activityType = sessionData?.current_fallback_activity;
-
-	// Log the activity completion to history if there was an active activity
-	if (activityType) {
-		const completedAt = new Date().toISOString();
+	const { session } = ctx;
+	const apiClient = getApiClient();
 
-		// Insert history record
-		await supabase.from('background_activity_history').insert({
-			project_id,
-			activity_type: activityType,
-			completed_at: completedAt,
-			completed_by_session_id: currentSessionId,
-			summary: summary || null,
-		});
+	const response = await apiClient.stopFallbackActivity(project_id, summary, session.currentSessionId || undefined);
 
-		// Update schedule if one exists for this activity
-		const { data: schedule } = await supabase
-			.from('background_activity_schedules')
-			.select('*')
-			.eq('project_id', project_id)
-			.eq('activity_type', activityType)
-			.eq('enabled', true)
-			.single();
-
-		if (schedule) {
-			let nextRunAt: string | null = null;
-			let enabled = true;
-
-			// Calculate next run time based on schedule type
-			const completedDate = new Date(completedAt);
-			switch (schedule.schedule_type) {
-				case 'once':
-					enabled = false;
-					break;
-				case 'daily':
-					completedDate.setDate(completedDate.getDate() + 1);
-					nextRunAt = completedDate.toISOString();
-					break;
-				case 'weekly':
-					completedDate.setDate(completedDate.getDate() + 7);
-					nextRunAt = completedDate.toISOString();
-					break;
-				case 'monthly':
-					completedDate.setDate(completedDate.getDate() + 30);
-					nextRunAt = completedDate.toISOString();
-					break;
-			}
-
-			await supabase
-				.from('background_activity_schedules')
-				.update({ next_run_at: nextRunAt, enabled })
-				.eq('id', schedule.id);
-		}
+	if (!response.ok) {
+		throw new Error(`Failed to stop fallback activity: ${response.error}`);
 	}
 
-	// Clear the current session's fallback activity
-	const { error: updateError } = await supabase
-		.from('agent_sessions')
-		.update({
-			current_fallback_activity: null,
-			status: 'idle',
-			last_synced_at: new Date().toISOString(),
-		})
-		.eq('id', currentSessionId);
-
-	if (updateError) throw updateError;
-
 	return {
 		result: {
 			success: true,
-			message: activityType
-				? `Fallback activity '${activityType}' completed and logged to history`
-				: 'Fallback activity stopped',
+			message: 'Fallback activity stopped',
 		},
 	};
 };
@@ -172,48 +107,33 @@ export const getActivityHistory: Handler = async (args, ctx) => {
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	const { supabase } = ctx;
-
-	let query = supabase
-		.from('background_activity_history')
-		.select(
-			`
-			id,
-			activity_type,
-			completed_at,
-			completed_by_session_id,
-			summary,
-			created_at,
-			agent_sessions!completed_by_session_id (
-				agent_name
-			)
-		`
-		)
-		.eq('project_id', project_id)
-		.order('completed_at', { ascending: false })
-		.limit(limit);
-
-	if (activity_type) {
-		query = query.eq('activity_type', activity_type);
-	}
-
-	const { data: history, error } = await query;
-
-	if (error) throw error;
-
-	// Also get the most recent completion for each activity type
-	const latestByType: Record<string, unknown> = {};
-	for (const entry of history || []) {
-		if (!latestByType[entry.activity_type]) {
-			latestByType[entry.activity_type] = entry;
-		}
+	const apiClient = getApiClient();
+
+	// Use proxy for get_activity_history operation
+	const response = await apiClient.proxy<{
+		history: Array<{
+			id: string;
+			activity_type: string;
+			completed_at: string;
+			summary?: string;
+		}>;
+		latest_by_type?: Record<string, unknown>;
+		count: number;
+	}>('get_activity_history', {
+		project_id,
+		activity_type,
+		limit
+	});
+
+	if (!response.ok) {
+		throw new Error(`Failed to get activity history: ${response.error}`);
 	}
 
 	return {
 		result: {
-			history: history || [],
-			latest_by_type: latestByType,
-			count: history?.length || 0,
+			history: response.data?.history || [],
+			latest_by_type: response.data?.latest_by_type || {},
+			count: response.data?.count || 0,
 		},
 	};
 };
@@ -224,27 +144,32 @@ export const getActivitySchedules: Handler = async (args, ctx) => {
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	const { supabase } = ctx;
-
-	const { data: schedules, error } = await supabase
-		.from('background_activity_schedules')
-		.select('*')
-		.eq('project_id', project_id)
-		.order('activity_type');
-
-	if (error) throw error;
-
-	// Identify which activities are "due" (next_run_at < now AND enabled)
-	const now = new Date();
-	const dueActivities = (schedules || [])
-		.filter((s) => s.enabled && s.next_run_at && new Date(s.next_run_at) < now)
-		.map((s) => s.activity_type);
+	const apiClient = getApiClient();
+
+	// Use proxy for get_activity_schedules operation
+	const response = await apiClient.proxy<{
+		schedules: Array<{
+			id: string;
+			activity_type: string;
+			schedule_type: string;
+			next_run_at?: string;
+			enabled: boolean;
+		}>;
+		due_activities: string[];
+		count: number;
+	}>('get_activity_schedules', {
+		project_id
+	});
+
+	if (!response.ok) {
+		throw new Error(`Failed to get activity schedules: ${response.error}`);
+	}
 
 	return {
 		result: {
-			schedules: schedules || [],
-			due_activities: dueActivities,
-			count: schedules?.length || 0,
+			schedules: response.data?.schedules || [],
+			due_activities: response.data?.due_activities || [],
+			count: response.data?.count || 0,
 		},
 	};
 };