@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/project.ts

@@ -9,75 +9,9 @@
  * - update_project_readme
  */
 
-import type { Handler, HandlerRegistry, UserUpdates, AuthContext } from './types.js';
-import type { SupabaseClient } from '@supabase/supabase-js';
+import type { Handler, HandlerRegistry } from './types.js';
 import { validateRequired, validateUUID, validateProjectStatus } from '../validators.js';
-
-/**
- * Get user-created items since last sync
- */
-async function getUserUpdates(
-	supabase: SupabaseClient,
-	auth: AuthContext,
-	projectId: string,
-	currentSessionId: string | null
-): Promise<UserUpdates | undefined> {
-	let lastSyncedAt: string;
-
-	if (currentSessionId) {
-		const { data: session } = await supabase
-			.from('agent_sessions')
-			.select('last_synced_at')
-			.eq('id', currentSessionId)
-			.single();
-		lastSyncedAt = session?.last_synced_at || new Date(0).toISOString();
-	} else {
-		const { data: session } = await supabase
-			.from('agent_sessions')
-			.select('last_synced_at')
-			.eq('api_key_id', auth.apiKeyId)
-			.eq('project_id', projectId)
-			.single();
-		lastSyncedAt = session?.last_synced_at || new Date(0).toISOString();
-	}
-
-	const [tasksResult, blockersResult, ideasResult] = await Promise.all([
-		supabase
-			.from('tasks')
-			.select('id, title, created_at')
-			.eq('project_id', projectId)
-			.eq('created_by', 'user')
-			.gt('created_at', lastSyncedAt)
-			.order('created_at', { ascending: false })
-			.limit(5),
-		supabase
-			.from('blockers')
-			.select('id, description, created_at')
-			.eq('project_id', projectId)
-			.eq('created_by', 'user')
-			.gt('created_at', lastSyncedAt)
-			.order('created_at', { ascending: false })
-			.limit(5),
-		supabase
-			.from('ideas')
-			.select('id, title, created_at')
-			.eq('project_id', projectId)
-			.eq('created_by', 'user')
-			.gt('created_at', lastSyncedAt)
-			.order('created_at', { ascending: false })
-			.limit(5),
-	]);
-
-	const tasks = tasksResult.data || [];
-	const blockers = blockersResult.data || [];
-	const ideas = ideasResult.data || [];
-
-	if (tasks.length === 0 && blockers.length === 0 && ideas.length === 0) {
-		return undefined;
-	}
-
-	return { tasks, blockers, ideas };
-}
+import { getApiClient } from '../api-client.js';
 
 export const getProjectContext: Handler = async (args, ctx) => {
 	const { project_id, git_url } = args as {
@@ -85,90 +19,36 @@ export const getProjectContext: Handler = async (args, ctx) => {
 		git_url?: string;
 	};
 
-	const { supabase, auth, session } = ctx;
+	const apiClient = getApiClient();
 
 	// If no project_id or git_url, list all projects
 	if (!project_id && !git_url) {
-		const { data: projects, error } = await supabase
-			.from('projects')
-			.select('id, name, description, status, git_url')
-			.eq('user_id', auth.userId)
-			.order('updated_at', { ascending: false });
+		const response = await apiClient.listProjects();
+
+		if (!response.ok) {
+			throw new Error(response.error || 'Failed to fetch projects');
+		}
 
-		if (error) throw new Error(`Failed to fetch projects: ${error.message}`);
-		return { result: { projects: projects || [] } };
+		return { result: { projects: response.data?.projects || [] } };
 	}
 
 	// Find project by ID or git_url
-	let query = supabase
-		.from('projects')
-		.select('id, name, description, goal, status, git_url, agent_instructions, tech_stack')
-		.eq('user_id', auth.userId);
+	const response = await apiClient.getProject(project_id || 'by-git-url', git_url);
 
-	if (project_id) {
-		query = query.eq('id', project_id);
-	} else if (git_url) {
-		query = query.eq('git_url', git_url);
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to fetch project');
 	}
 
-	const { data: project, error: projectError } = await query.single();
-
-	if (projectError || !project) {
+	if (!response.data?.found) {
 		return {
 			result: {
 				found: false,
-				message: 'Project not found. Use create_project to create one.',
+				message: response.data?.message || 'Project not found. Use create_project to create one.',
 			},
 		};
 	}
 
-	// Fetch related data with minimal fields
-	const [tasksResult, blockersResult, decisionsResult, progressResult] = await Promise.all([
-		supabase
-			.from('tasks')
-			.select('id, title, description, priority, status, estimated_minutes')
-			.eq('project_id', project.id)
-			.in('status', ['pending', 'in_progress'])
-			.order('priority', { ascending: true })
-			.limit(10),
-		supabase
-			.from('blockers')
-			.select('id, description')
-			.eq('project_id', project.id)
-			.eq('status', 'open')
-			.limit(5),
-		supabase
-			.from('decisions')
-			.select('title')
-			.eq('project_id', project.id)
-			.order('created_at', { ascending: false })
-			.limit(5),
-		supabase
-			.from('progress_logs')
-			.select('summary')
-			.eq('project_id', project.id)
-			.order('created_at', { ascending: false })
-			.limit(5),
-	]);
-
-	const userUpdates = await getUserUpdates(supabase, auth, project.id, session.currentSessionId);
-
-	// Build compact response
-	const result: Record<string, unknown> = {
-		found: true,
-		project,
-		active_tasks: tasksResult.data || [],
-	};
-
-	const blockers = blockersResult.data || [];
-	const decisions = decisionsResult.data || [];
-	const progress = progressResult.data || [];
-
-	if (blockers.length > 0) result.open_blockers = blockers;
-	if (decisions.length > 0) result.recent_decisions = decisions;
-	if (progress.length > 0) result.recent_progress = progress;
-
-	return { result, user_updates: userUpdates } as { result: Record<string, unknown>; user_updates?: UserUpdates };
+	return { result: response.data };
 };
 
 export const getGitWorkflow: Handler = async (args, ctx) => {
@@ -180,79 +60,14 @@ export const getGitWorkflow: Handler = async (args, ctx) => {
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	const { supabase } = ctx;
-
-	const { data: project, error } = await supabase
-		.from('projects')
-		.select('git_workflow, git_main_branch, git_develop_branch, git_auto_branch, git_auto_tag, git_url')
-		.eq('id', project_id)
-		.single();
-
-	if (error || !project) throw new Error(`Project not found: ${project_id}`);
-
-	let task = null;
-	if (task_id) {
-		const { data: taskData } = await supabase
-			.from('tasks')
-			.select('id, title, git_branch')
-			.eq('id', task_id)
-			.single();
-		task = taskData;
-	}
-
-	// Generate workflow instructions
-	const workflow = project.git_workflow || 'none';
-	const mainBranch = project.git_main_branch || 'main';
-	const developBranch = project.git_develop_branch || 'develop';
-
-	const instructions: Record<string, string[]> = {
-		'none': [
-			'No git workflow configured for this project.',
-			'Commit changes directly without branching strategy.',
-		],
-		'trunk-based': [
-			`Work directly on the ${mainBranch} branch.`,
-			'Make small, frequent commits.',
-			'Ensure all tests pass before committing.',
-			`Tag deployments on ${mainBranch} (e.g., git tag v1.0.0).`,
-		],
-		'github-flow': [
-			task ? `Create feature branch: git checkout -b feature/${task.id.slice(0, 8)}-${task.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 30)}` : 'Create a feature branch for each task.',
-			'Make commits with descriptive messages.',
-			'Push branch and create a pull request.',
-			`Merge to ${mainBranch} after review/validation.`,
-			project.git_auto_tag ? 'Deployments will be automatically tagged.' : `Tag deployments manually on ${mainBranch}.`,
-		],
-		'git-flow': [
-			task ? `Create feature branch from ${developBranch}: git checkout -b feature/${task.id.slice(0, 8)}-${task.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 30)} ${developBranch}` : `Create feature branches from ${developBranch}.`,
-			`Merge completed features back to ${developBranch}.`,
-			`Create release branches from ${developBranch} when ready.`,
-			`Merge releases to both ${mainBranch} and ${developBranch}.`,
-			`Tag releases on ${mainBranch}.`,
-		],
-	};
-
-	const result: Record<string, unknown> = {
-		workflow,
-		main_branch: mainBranch,
-		develop_branch: workflow === 'git-flow' ? developBranch : null,
-		auto_branch: project.git_auto_branch,
-		auto_tag: project.git_auto_tag,
-		instructions: instructions[workflow] || instructions['none'],
-	};
+	const apiClient = getApiClient();
+	const response = await apiClient.getGitWorkflow(project_id, task_id);
 
-	if (task) {
-		result.task = {
-			id: task.id,
-			title: task.title,
-			current_branch: task.git_branch,
-			suggested_branch: workflow !== 'none' && workflow !== 'trunk-based'
-				? `feature/${task.id.slice(0, 8)}-${task.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 30)}`
-				: null,
-		};
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to get git workflow');
 	}
 
-	return { result };
+	return { result: response.data };
 };
 
 export const createProject: Handler = async (args, ctx) => {
@@ -264,23 +79,22 @@ export const createProject: Handler = async (args, ctx) => {
 		tech_stack?: string[];
 	};
 
-	const { supabase, auth } = ctx;
+	validateRequired(name, 'name');
+
+	const apiClient = getApiClient();
+	const response = await apiClient.createProject({
+		name,
+		description,
+		goal,
+		git_url,
+		tech_stack
+	});
 
-	const { data, error } = await supabase
-		.from('projects')
-		.insert({
-			user_id: auth.userId,
-			name,
-			description: description || null,
-			goal: goal || null,
-			git_url: git_url || null,
-			tech_stack: tech_stack || null,
-		})
-		.select()
-		.single();
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to create project');
+	}
 
-	if (error) throw new Error(`Failed to create project: ${error.message}`);
-	return { result: { success: true, project: data } };
+	return { result: response.data };
 };
 
 export const updateProject: Handler = async (args, ctx) => {
@@ -297,6 +111,8 @@ export const updateProject: Handler = async (args, ctx) => {
 		git_develop_branch?: string;
 		git_auto_branch?: boolean;
 		git_auto_tag?: boolean;
+		git_auto_commit_on_complete?: boolean;
+		git_auto_pr_on_complete?: boolean;
 		deployment_instructions?: string;
 	};
 
@@ -304,17 +120,14 @@ export const updateProject: Handler = async (args, ctx) => {
 	validateUUID(project_id, 'project_id');
 	validateProjectStatus(updates.status);
 
-	const { supabase, auth } = ctx;
-
-	const { error } = await supabase
-		.from('projects')
-		.update(updates)
-		.eq('id', project_id)
-		.eq('user_id', auth.userId);
+	const apiClient = getApiClient();
+	const response = await apiClient.updateProject(project_id, updates);
 
-	if (error) throw new Error(`Failed to update project: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to update project');
+	}
 
-	return { result: { success: true, project_id } };
+	return { result: response.data };
 };
 
 export const updateProjectReadme: Handler = async (args, ctx) => {
@@ -327,17 +140,14 @@ export const updateProjectReadme: Handler = async (args, ctx) => {
 	validateUUID(project_id, 'project_id');
 	validateRequired(readme_content, 'readme_content');
 
-	const { error } = await ctx.supabase
-		.from('projects')
-		.update({
-			readme_content,
-			readme_updated_at: new Date().toISOString(),
-		})
-		.eq('id', project_id);
+	const apiClient = getApiClient();
+	const response = await apiClient.updateProjectReadme(project_id, readme_content);
 
-	if (error) throw new Error(`Failed to update README: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to update README');
+	}
 
-	return { result: { success: true } };
+	return { result: response.data };
 };
 
 /**