@vibescope/mcp-server 0.0.1 → 0.2.0

package/dist/handlers/progress.js

@@ -4,141 +4,43 @@
  * Handles progress logging and activity feed:
  * - log_progress
  * - get_activity_feed
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
 import { validateRequired, validateUUID } from '../validators.js';
+import { getApiClient } from '../api-client.js';
 export const logProgress = async (args, ctx) => {
     const { project_id, task_id, summary, details } = args;
-    const { supabase, session } = ctx;
-    const { error } = await supabase
-        .from('progress_logs')
-        .insert({
-        project_id,
-        task_id: task_id || null,
+    validateRequired(project_id, 'project_id');
+    validateUUID(project_id, 'project_id');
+    validateRequired(summary, 'summary');
+    const { session } = ctx;
+    const apiClient = getApiClient();
+    const response = await apiClient.logProgress(project_id, {
         summary,
-        details: details || null,
-        created_by: 'agent',
-        created_by_session_id: session.currentSessionId,
+        details,
+        task_id,
+        session_id: session.currentSessionId || undefined
     });
-    if (error)
-        throw new Error(`Failed to log progress: ${error.message}`);
-    return { result: { success: true } };
+    if (!response.ok) {
+        throw new Error(`Failed to log progress: ${response.error}`);
+    }
+    return { result: { success: true, progress_id: response.data?.progress_id } };
 };
 export const getActivityFeed = async (args, ctx) => {
-    const { project_id, types, created_by, since, limit = 50 } = args;
+    const { project_id, limit = 50, since } = args;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
-    const { supabase } = ctx;
+    const apiClient = getApiClient();
     const effectiveLimit = Math.min(limit, 200);
-    const includeTypes = types || ['task', 'progress', 'blocker', 'decision'];
-    // Fetch slightly more per type to account for interleaving, but not full limit
-    const perTypeLimit = Math.min(Math.ceil(effectiveLimit / includeTypes.length) * 2, effectiveLimit);
-    const activities = [];
-    // Fetch tasks if included
-    if (includeTypes.includes('task')) {
-        let query = supabase
-            .from('tasks')
-            .select('id, title, status, created_by, created_at, completed_at')
-            .eq('project_id', project_id)
-            .order('created_at', { ascending: false })
-            .limit(perTypeLimit);
-        if (created_by)
-            query = query.eq('created_by', created_by);
-        if (since)
-            query = query.gt('created_at', since);
-        const { data: tasks } = await query;
-        if (tasks) {
-            for (const task of tasks) {
-                activities.push({
-                    type: 'task',
-                    id: task.id,
-                    title: task.title,
-                    status: task.status,
-                    created_by: task.created_by,
-                    created_at: task.created_at,
-                });
-            }
-        }
-    }
-    // Fetch progress logs if included
-    if (includeTypes.includes('progress')) {
-        let query = supabase
-            .from('progress_logs')
-            .select('id, summary, created_by, created_at')
-            .eq('project_id', project_id)
-            .order('created_at', { ascending: false })
-            .limit(perTypeLimit);
-        if (created_by)
-            query = query.eq('created_by', created_by);
-        if (since)
-            query = query.gt('created_at', since);
-        const { data: logs } = await query;
-        if (logs) {
-            for (const log of logs) {
-                activities.push({
-                    type: 'progress',
-                    id: log.id,
-                    summary: log.summary,
-                    created_by: log.created_by,
-                    created_at: log.created_at,
-                });
-            }
-        }
-    }
-    // Fetch blockers if included
-    if (includeTypes.includes('blocker')) {
-        let query = supabase
-            .from('blockers')
-            .select('id, description, status, created_by, created_at')
-            .eq('project_id', project_id)
-            .order('created_at', { ascending: false })
-            .limit(perTypeLimit);
-        if (created_by)
-            query = query.eq('created_by', created_by);
-        if (since)
-            query = query.gt('created_at', since);
-        const { data: blockers } = await query;
-        if (blockers) {
-            for (const blocker of blockers) {
-                activities.push({
-                    type: 'blocker',
-                    id: blocker.id,
-                    description: blocker.description,
-                    status: blocker.status,
-                    created_by: blocker.created_by,
-                    created_at: blocker.created_at,
-                });
-            }
-        }
-    }
-    // Fetch decisions if included
-    if (includeTypes.includes('decision')) {
-        let query = supabase
-            .from('decisions')
-            .select('id, title, created_by, created_at')
-            .eq('project_id', project_id)
-            .order('created_at', { ascending: false })
-            .limit(perTypeLimit);
-        if (created_by)
-            query = query.eq('created_by', created_by);
-        if (since)
-            query = query.gt('created_at', since);
-        const { data: decisions } = await query;
-        if (decisions) {
-            for (const decision of decisions) {
-                activities.push({
-                    type: 'decision',
-                    id: decision.id,
-                    title: decision.title,
-                    created_by: decision.created_by,
-                    created_at: decision.created_at,
-                });
-            }
-        }
+    const response = await apiClient.getActivityFeed(project_id, {
+        limit: effectiveLimit,
+        since
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch activity feed: ${response.error}`);
     }
-    // Sort by created_at descending and limit
-    activities.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
-    const limitedActivities = activities.slice(0, effectiveLimit);
-    return { result: { activities: limitedActivities } };
+    return { result: { activities: response.data?.activities || [] } };
 };
 /**
  * Progress handlers registry

package/dist/handlers/project.js

@@ -9,262 +9,83 @@
  * - update_project_readme
  */
 import { validateRequired, validateUUID, validateProjectStatus } from '../validators.js';
-/**
- * Get user-created items since last sync
- */
-async function getUserUpdates(supabase, auth, projectId, currentSessionId) {
-    let lastSyncedAt;
-    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 = async (args, ctx) => {
     const { project_id, git_url } = args;
-    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 });
-        if (error)
-            throw new Error(`Failed to fetch projects: ${error.message}`);
-        return { result: { projects: projects || [] } };
+        const response = await apiClient.listProjects();
+        if (!response.ok) {
+            throw new Error(response.error || 'Failed to fetch 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);
-    if (project_id) {
-        query = query.eq('id', project_id);
-    }
-    else if (git_url) {
-        query = query.eq('git_url', git_url);
+    const response = await apiClient.getProject(project_id || 'by-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 = {
-        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 };
+    return { result: response.data };
 };
 export const getGitWorkflow = async (args, ctx) => {
     const { project_id, task_id } = args;
     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;
+    const apiClient = getApiClient();
+    const response = await apiClient.getGitWorkflow(project_id, task_id);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to get git workflow');
     }
-    // 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 = {
-        '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 = {
-        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'],
-    };
-    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,
-        };
-    }
-    return { result };
+    return { result: response.data };
 };
 export const createProject = async (args, ctx) => {
     const { name, description, goal, git_url, tech_stack } = args;
-    const { supabase, auth } = ctx;
-    const { data, error } = await supabase
-        .from('projects')
-        .insert({
-        user_id: auth.userId,
+    validateRequired(name, 'name');
+    const apiClient = getApiClient();
+    const response = await apiClient.createProject({
         name,
-        description: description || null,
-        goal: goal || null,
-        git_url: git_url || null,
-        tech_stack: tech_stack || null,
-    })
-        .select()
-        .single();
-    if (error)
-        throw new Error(`Failed to create project: ${error.message}`);
-    return { result: { success: true, project: data } };
+        description,
+        goal,
+        git_url,
+        tech_stack
+    });
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to create project');
+    }
+    return { result: response.data };
 };
 export const updateProject = async (args, ctx) => {
     const { project_id, ...updates } = args;
     validateRequired(project_id, 'project_id');
     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);
-    if (error)
-        throw new Error(`Failed to update project: ${error.message}`);
-    return { result: { success: true, project_id } };
+    const apiClient = getApiClient();
+    const response = await apiClient.updateProject(project_id, updates);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to update project');
+    }
+    return { result: response.data };
 };
 export const updateProjectReadme = async (args, ctx) => {
     const { project_id, readme_content } = args;
     validateRequired(project_id, 'project_id');
     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);
-    if (error)
-        throw new Error(`Failed to update README: ${error.message}`);
-    return { result: { success: true } };
+    const apiClient = getApiClient();
+    const response = await apiClient.updateProjectReadme(project_id, readme_content);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to update README');
+    }
+    return { result: response.data };
 };
 /**
  * Project handlers registry

package/dist/handlers/requests.d.ts

@@ -5,6 +5,8 @@
  * - get_pending_requests
  * - acknowledge_request
  * - answer_question
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
 import type { Handler, HandlerRegistry } from './types.js';
 export declare const getPendingRequests: Handler;

package/dist/handlers/requests.js

@@ -5,68 +5,25 @@
  * - get_pending_requests
  * - acknowledge_request
  * - answer_question
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
 import { validateRequired, validateUUID } from '../validators.js';
+import { getApiClient } from '../api-client.js';
 export const getPendingRequests = async (args, ctx) => {
     const { project_id } = args;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
-    const { supabase, session } = ctx;
-    const currentSessionId = session.currentSessionId;
-    // Get active session IDs to identify orphaned questions
-    const { data: activeSessions } = await supabase
-        .from('agent_sessions')
-        .select('id')
-        .eq('project_id', project_id)
-        .eq('status', 'active');
-    const activeSessionIds = new Set((activeSessions || []).map((s) => s.id));
-    // Get pending requests for this project:
-    // - Unacknowledged requests OR unanswered questions (questions need answers, not just acknowledgment)
-    const { data: requests, error } = await supabase
-        .from('agent_requests')
-        .select('*')
-        .eq('project_id', project_id)
-        .or('acknowledged_at.is.null,and(request_type.eq.question,answered_at.is.null)')
-        .order('created_at', { ascending: false });
-    if (error)
-        throw error;
-    // Filter to requests this agent can handle
-    const filteredRequests = (requests || []).filter((r) => {
-        // Broadcast requests (session_id is null) - anyone can handle
-        if (!r.session_id)
-            return true;
-        // Targeted to this session
-        if (r.session_id === currentSessionId)
-            return true;
-        // Orphaned questions (targeted session is disconnected) - any agent can answer
-        if (r.request_type === 'question' && !activeSessionIds.has(r.session_id))
-            return true;
-        return false;
-    });
-    // Sort questions first (highest priority) and add wait times
-    const now = new Date();
-    const sortedRequests = filteredRequests
-        .map((r) => ({
-        ...r,
-        wait_minutes: Math.floor((now.getTime() - new Date(r.created_at).getTime()) / 60000),
-    }))
-        .sort((a, b) => {
-        // Questions first, then by created_at (oldest first for urgency)
-        const aIsQuestion = a.request_type === 'question' && !a.answered_at;
-        const bIsQuestion = b.request_type === 'question' && !b.answered_at;
-        if (aIsQuestion && !bIsQuestion)
-            return -1;
-        if (!aIsQuestion && bIsQuestion)
-            return 1;
-        return new Date(a.created_at).getTime() - new Date(b.created_at).getTime();
-    });
-    // Count unanswered questions separately
-    const questionsCount = sortedRequests.filter((r) => r.request_type === 'question' && !r.answered_at).length;
+    const { session } = ctx;
+    const apiClient = getApiClient();
+    const response = await apiClient.getPendingRequests(project_id, session.currentSessionId || undefined);
+    if (!response.ok) {
+        throw new Error(`Failed to get pending requests: ${response.error}`);
+    }
     return {
         result: {
-            requests: sortedRequests,
-            count: sortedRequests.length,
-            questions_count: questionsCount,
+            requests: response.data?.requests || [],
+            count: response.data?.requests?.length || 0,
         },
     };
 };
@@ -74,22 +31,15 @@ export const acknowledgeRequest = async (args, ctx) => {
     const { request_id } = args;
     validateRequired(request_id, 'request_id');
     validateUUID(request_id, 'request_id');
-    const { supabase, session } = ctx;
-    const { data: request, error } = await supabase
-        .from('agent_requests')
-        .update({
-        acknowledged_at: new Date().toISOString(),
-        acknowledged_by_session_id: session.currentSessionId,
-    })
-        .eq('id', request_id)
-        .select()
-        .single();
-    if (error)
-        throw error;
+    const { session } = ctx;
+    const apiClient = getApiClient();
+    const response = await apiClient.acknowledgeRequest(request_id, session.currentSessionId || undefined);
+    if (!response.ok) {
+        throw new Error(`Failed to acknowledge request: ${response.error}`);
+    }
     return {
         result: {
             success: true,
-            request,
         },
     };
 };
@@ -98,26 +48,16 @@ export const answerQuestion = async (args, ctx) => {
     validateRequired(request_id, 'request_id');
     validateRequired(answer, 'answer');
     validateUUID(request_id, 'request_id');
-    const { supabase, session } = ctx;
-    // Update the request with the answer
-    const { data: request, error } = await supabase
-        .from('agent_requests')
-        .update({
-        answer,
-        answered_at: new Date().toISOString(),
-        acknowledged_at: new Date().toISOString(),
-        acknowledged_by_session_id: session.currentSessionId,
-    })
-        .eq('id', request_id)
-        .select()
-        .single();
-    if (error)
-        throw error;
+    const { session } = ctx;
+    const apiClient = getApiClient();
+    const response = await apiClient.answerQuestion(request_id, answer, session.currentSessionId || undefined);
+    if (!response.ok) {
+        throw new Error(`Failed to answer question: ${response.error}`);
+    }
     return {
         result: {
             success: true,
             message: 'Question answered successfully',
-            request,
         },
     };
 };