@vibescope/mcp-server 0.0.1

package/src/handlers/fallback.ts

@@ -0,0 +1,260 @@
+/**
+ * Fallback Handlers
+ *
+ * Handles background activities when idle:
+ * - start_fallback_activity
+ * - stop_fallback_activity
+ * - get_activity_history
+ * - get_activity_schedules
+ */
+
+import type { Handler, HandlerRegistry } from './types.js';
+import { validateRequired, validateUUID } from '../validators.js';
+import { FALLBACK_ACTIVITIES } from '../utils.js';
+
+const VALID_ACTIVITIES = [
+	'feature_ideation',
+	'code_review',
+	'performance_audit',
+	'ux_review',
+	'cost_analysis',
+	'security_review',
+	'test_coverage',
+	'documentation_review',
+	'dependency_audit',
+	'validate_completed_tasks',
+];
+
+export const startFallbackActivity: Handler = async (args, ctx) => {
+	const { project_id, activity } = args as { project_id: string; activity: string };
+
+	validateRequired(project_id, 'project_id');
+	validateUUID(project_id, 'project_id');
+	validateRequired(activity, 'activity');
+
+	if (!VALID_ACTIVITIES.includes(activity)) {
+		throw new Error(`Invalid activity. Must be one of: ${VALID_ACTIVITIES.join(', ')}`);
+	}
+
+	const { supabase, session } = ctx;
+	const currentSessionId = session.currentSessionId;
+
+	// 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);
+
+	if (updateError) throw updateError;
+
+	// 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}`,
+		},
+	};
+};
+
+export const stopFallbackActivity: Handler = async (args, ctx) => {
+	const { project_id, summary } = args as { project_id: string; summary?: string };
+
+	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();
+
+		// 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,
+		});
+
+		// 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);
+		}
+	}
+
+	// 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',
+		},
+	};
+};
+
+export const getActivityHistory: Handler = async (args, ctx) => {
+	const { project_id, activity_type, limit = 50 } = args as {
+		project_id: string;
+		activity_type?: string;
+		limit?: number;
+	};
+
+	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;
+		}
+	}
+
+	return {
+		result: {
+			history: history || [],
+			latest_by_type: latestByType,
+			count: history?.length || 0,
+		},
+	};
+};
+
+export const getActivitySchedules: Handler = async (args, ctx) => {
+	const { project_id } = args as { project_id: string };
+
+	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);
+
+	return {
+		result: {
+			schedules: schedules || [],
+			due_activities: dueActivities,
+			count: schedules?.length || 0,
+		},
+	};
+};
+
+/**
+ * Fallback handlers registry
+ */
+export const fallbackHandlers: HandlerRegistry = {
+	start_fallback_activity: startFallbackActivity,
+	stop_fallback_activity: stopFallbackActivity,
+	get_activity_history: getActivityHistory,
+	get_activity_schedules: getActivitySchedules,
+};