@vibescope/mcp-server 0.0.1 → 0.2.0

package/dist/handlers/fallback.js

@@ -6,9 +6,12 @@
  * - stop_fallback_activity
  * - get_activity_history
  * - get_activity_schedules
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
 import { validateRequired, validateUUID } from '../validators.js';
 import { FALLBACK_ACTIVITIES } from '../utils.js';
+import { getApiClient } from '../api-client.js';
 const VALID_ACTIVITIES = [
     'feature_ideation',
     'code_review',
@@ -29,112 +32,48 @@ export const startFallbackActivity = async (args, ctx) => {
     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;
+    const { session } = ctx;
+    const apiClient = getApiClient();
+    const response = await apiClient.startFallbackActivity(project_id, activity, session.currentSessionId || undefined);
+    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 = {
+        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 = async (args, ctx) => {
     const { project_id, summary } = args;
     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 = 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);
-        }
+    const { session } = ctx;
+    const apiClient = getApiClient();
+    const response = await apiClient.stopFallbackActivity(project_id, summary, session.currentSessionId || undefined);
+    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',
         },
     };
 };
@@ -142,41 +81,21 @@ export const getActivityHistory = async (args, ctx) => {
     const { project_id, activity_type, limit = 50 } = args;
     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 = {};
-    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('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,
         },
     };
 };
@@ -184,24 +103,19 @@ export const getActivitySchedules = async (args, ctx) => {
     const { project_id } = args;
     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('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,
         },
     };
 };

package/dist/handlers/findings.d.ts

@@ -3,13 +3,20 @@
  *
  * Handles audit findings and knowledge base:
  * - add_finding
- * - get_findings
+ * - get_findings (supports summary_only for reduced tokens)
+ * - get_findings_stats (aggregate counts for minimal tokens)
  * - update_finding
  * - delete_finding
  */
 import type { Handler, HandlerRegistry } from './types.js';
 export declare const addFinding: Handler;
 export declare const getFindings: Handler;
+/**
+ * Get aggregate statistics about findings for a project.
+ * Returns counts by category, severity, and status without the actual finding data.
+ * This is much more token-efficient than get_findings for understanding the overall state.
+ */
+export declare const getFindingsStats: Handler;
 export declare const updateFinding: Handler;
 export declare const deleteFinding: Handler;
 /**

package/dist/handlers/findings.js

@@ -3,11 +3,13 @@
  *
  * Handles audit findings and knowledge base:
  * - add_finding
- * - get_findings
+ * - get_findings (supports summary_only for reduced tokens)
+ * - get_findings_stats (aggregate counts for minimal tokens)
  * - update_finding
  * - delete_finding
  */
 import { validateRequired, validateUUID } from '../validators.js';
+import { getApiClient } from '../api-client.js';
 export const addFinding = async (args, ctx) => {
     const { project_id, category, title, description, severity, file_path, line_number, related_task_id } = args;
     validateRequired(project_id, 'project_id');
@@ -15,89 +17,83 @@ export const addFinding = async (args, ctx) => {
     validateRequired(title, 'title');
     if (related_task_id)
         validateUUID(related_task_id, 'related_task_id');
-    const { supabase, session } = ctx;
-    const { data, error } = await supabase
-        .from('findings')
-        .insert({
-        project_id,
-        category: category || 'other',
+    const apiClient = getApiClient();
+    const response = await apiClient.addFinding(project_id, {
         title,
-        description: description || null,
-        severity: severity || 'info',
-        file_path: file_path || null,
-        line_number: line_number || null,
-        related_task_id: related_task_id || null,
-        created_by: 'agent',
-        created_by_session_id: session.currentSessionId,
-    })
-        .select('id')
-        .single();
-    if (error)
-        throw new Error(`Failed to add finding: ${error.message}`);
-    return { result: { success: true, finding_id: data.id, title } };
+        description,
+        category,
+        severity,
+        file_path,
+        line_number,
+        related_task_id
+    }, ctx.session.currentSessionId || undefined);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to add finding');
+    }
+    return { result: response.data };
 };
 export const getFindings = async (args, ctx) => {
-    const { project_id, category, severity, status, limit } = args;
+    const { project_id, category, severity, status, limit = 50, offset = 0, search_query, summary_only = false } = args;
+    validateRequired(project_id, 'project_id');
+    validateUUID(project_id, 'project_id');
+    const apiClient = getApiClient();
+    const response = await apiClient.getFindings(project_id, {
+        category,
+        severity,
+        status,
+        limit,
+        offset,
+        search_query,
+        summary_only
+    });
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to get findings');
+    }
+    return { result: response.data };
+};
+/**
+ * Get aggregate statistics about findings for a project.
+ * Returns counts by category, severity, and status without the actual finding data.
+ * This is much more token-efficient than get_findings for understanding the overall state.
+ */
+export const getFindingsStats = async (args, ctx) => {
+    const { project_id } = args;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
-    const { supabase } = ctx;
-    let query = supabase
-        .from('findings')
-        .select('id, title, category, severity, status, file_path, created_at')
-        .eq('project_id', project_id)
-        .order('created_at', { ascending: false })
-        .limit(limit || 50);
-    if (category)
-        query = query.eq('category', category);
-    if (severity)
-        query = query.eq('severity', severity);
-    if (status)
-        query = query.eq('status', status);
-    const { data, error } = await query;
-    if (error)
-        throw new Error(`Failed to get findings: ${error.message}`);
-    return { result: { findings: data } };
+    const apiClient = getApiClient();
+    const response = await apiClient.getFindingsStats(project_id);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to get findings stats');
+    }
+    return { result: response.data };
 };
 export const updateFinding = async (args, ctx) => {
     const { finding_id, status, resolution_note, title, description, severity } = args;
     validateRequired(finding_id, 'finding_id');
     validateUUID(finding_id, 'finding_id');
-    const { supabase, session } = ctx;
-    const updates = { updated_at: new Date().toISOString() };
-    if (title)
-        updates.title = title;
-    if (description)
-        updates.description = description;
-    if (severity)
-        updates.severity = severity;
-    if (status) {
-        updates.status = status;
-        if (status === 'addressed' || status === 'dismissed' || status === 'wontfix') {
-            updates.addressed_at = new Date().toISOString();
-            updates.addressed_by_session_id = session.currentSessionId;
-        }
+    const apiClient = getApiClient();
+    const response = await apiClient.updateFinding(finding_id, {
+        title,
+        description,
+        severity,
+        status,
+        resolution_note
+    });
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to update finding');
     }
-    if (resolution_note)
-        updates.resolution_note = resolution_note;
-    const { error } = await supabase
-        .from('findings')
-        .update(updates)
-        .eq('id', finding_id);
-    if (error)
-        throw new Error(`Failed to update finding: ${error.message}`);
-    return { result: { success: true, finding_id } };
+    return { result: response.data };
 };
 export const deleteFinding = async (args, ctx) => {
     const { finding_id } = args;
     validateRequired(finding_id, 'finding_id');
     validateUUID(finding_id, 'finding_id');
-    const { error } = await ctx.supabase
-        .from('findings')
-        .delete()
-        .eq('id', finding_id);
-    if (error)
-        throw new Error(`Failed to delete finding: ${error.message}`);
-    return { result: { success: true } };
+    const apiClient = getApiClient();
+    const response = await apiClient.deleteFinding(finding_id);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to delete finding');
+    }
+    return { result: response.data };
 };
 /**
  * Findings handlers registry
@@ -105,6 +101,7 @@ export const deleteFinding = async (args, ctx) => {
 export const findingHandlers = {
     add_finding: addFinding,
     get_findings: getFindings,
+    get_findings_stats: getFindingsStats,
     update_finding: updateFinding,
     delete_finding: deleteFinding,
 };

package/dist/handlers/git-issues.d.ts

@@ -1,22 +1,18 @@
 /**
  * Git Issues Handlers
  *
- * Handles git-related issue tracking:
- * - get_git_issues
- * - create_git_issue
- * - resolve_git_issue
- * - dismiss_git_issue
+ * Handles git issue management:
+ * - add_git_issue: Record a git-related issue (conflicts, push failures, etc.)
+ * - resolve_git_issue: Mark a git issue as resolved
+ * - get_git_issues: List git issues for a project
+ * - delete_git_issue: Remove a git issue
  */
 import type { Handler, HandlerRegistry } from './types.js';
-export declare const getGitIssues: Handler;
-export declare const createGitIssue: Handler;
+export declare const addGitIssue: Handler;
 export declare const resolveGitIssue: Handler;
-export declare const dismissGitIssue: Handler;
-/**
- * Auto-resolve git issues for a branch when it becomes mergeable
- */
-export declare function autoResolveGitIssuesForBranch(supabase: import('@supabase/supabase-js').SupabaseClient, projectId: string, branchName: string, sessionId: string | null): Promise<number>;
+export declare const getGitIssues: Handler;
+export declare const deleteGitIssue: Handler;
 /**
  * Git Issues handlers registry
  */
-export declare const gitIssuesHandlers: HandlerRegistry;
+export declare const gitIssueHandlers: HandlerRegistry;