@vibescope/mcp-server 0.0.1 → 0.1.0

package/dist/handlers/discovery.js

@@ -183,6 +183,12 @@ const TOOL_CATEGORIES = {
             { name: 'get_task_costs', brief: 'Cost per task' },
         ],
     },
+    knowledge: {
+        description: 'Queryable knowledge base from project data',
+        tools: [
+            { name: 'query_knowledge_base', brief: 'Aggregated project knowledge in one call' },
+        ],
+    },
 };
 // Detailed tool info (fetched on-demand)
 const TOOL_INFO = {
@@ -809,6 +815,31 @@ Get cost breakdown by task for a project.
 - limit: Max tasks to return (default: 20)
 
 **Returns:** Tasks sorted by estimated cost with model breakdown`,
+    // Knowledge base tools
+    query_knowledge_base: `# query_knowledge_base
+Query aggregated project knowledge in a single call. Reduces token usage by combining multiple data sources.
+
+**Parameters:**
+- project_id (required): Project UUID
+- scope: 'summary' (default) or 'detailed' (includes rationales, descriptions)
+- categories: Array of categories to include (default: all)
+  - findings: Audit findings (security, performance, code quality)
+  - qa: Questions and answers
+  - decisions: Architectural decisions
+  - completed_tasks: Tasks with completion summaries
+  - blockers: Resolved blockers with resolution notes
+  - progress: Recent progress logs
+- limit: Max items per category (default: 5, max: 20)
+- search_query: Optional text search across all knowledge
+
+**Returns:**
+- project: name, goal, tech_stack
+- stats: counts for each category, findings by severity
+- Category data based on selection
+
+**Token savings:** Replaces up to 6 separate tool calls (get_findings, get_decisions, get_tasks, get_blockers, etc.) with one call.
+
+**Example:** query_knowledge_base(project_id, categories: ["findings", "decisions"], limit: 10)`,
 };
 export const discoverTools = async (args) => {
     const { category } = args;

package/dist/handlers/fallback.d.ts

@@ -6,6 +6,8 @@
  * - 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';
 export declare const startFallbackActivity: Handler;

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,20 +32,12 @@ 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 {
@@ -52,7 +47,7 @@ export const startFallbackActivity = async (args, ctx) => {
             title: activityInfo?.title || activity,
             description: activityInfo?.description || '',
             prompt: activityInfo?.prompt || '',
-            message: `Started fallback activity: ${activityInfo?.title || activity}`,
+            message: response.data?.message || `Started fallback activity: ${activityInfo?.title || activity}`,
         },
     };
 };
@@ -60,81 +55,16 @@ 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 +72,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 +94,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.js

@@ -8,6 +8,7 @@
  * - 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 +16,64 @@ 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 } = 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.getFindings(project_id, {
+        category,
+        severity,
+        status,
+        limit
+    });
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to get findings');
+    }
+    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

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;