@vibescope/mcp-server 0.0.1

package/dist/handlers/fallback.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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';
+export declare const startFallbackActivity: Handler;
+export declare const stopFallbackActivity: Handler;
+export declare const getActivityHistory: Handler;
+export declare const getActivitySchedules: Handler;
+/**
+ * Fallback handlers registry
+ */
+export declare const fallbackHandlers: HandlerRegistry;

package/dist/handlers/fallback.js

@@ -0,0 +1,216 @@
+/**
+ * Fallback Handlers
+ *
+ * Handles background activities when idle:
+ * - start_fallback_activity
+ * - stop_fallback_activity
+ * - get_activity_history
+ * - get_activity_schedules
+ */
+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 = async (args, ctx) => {
+    const { project_id, activity } = args;
+    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 = 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);
+        }
+    }
+    // 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 = 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;
+        }
+    }
+    return {
+        result: {
+            history: history || [],
+            latest_by_type: latestByType,
+            count: history?.length || 0,
+        },
+    };
+};
+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);
+    return {
+        result: {
+            schedules: schedules || [],
+            due_activities: dueActivities,
+            count: schedules?.length || 0,
+        },
+    };
+};
+/**
+ * Fallback handlers registry
+ */
+export const fallbackHandlers = {
+    start_fallback_activity: startFallbackActivity,
+    stop_fallback_activity: stopFallbackActivity,
+    get_activity_history: getActivityHistory,
+    get_activity_schedules: getActivitySchedules,
+};

package/dist/handlers/findings.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Findings Handlers
+ *
+ * Handles audit findings and knowledge base:
+ * - add_finding
+ * - get_findings
+ * - update_finding
+ * - delete_finding
+ */
+import type { Handler, HandlerRegistry } from './types.js';
+export declare const addFinding: Handler;
+export declare const getFindings: Handler;
+export declare const updateFinding: Handler;
+export declare const deleteFinding: Handler;
+/**
+ * Findings handlers registry
+ */
+export declare const findingHandlers: HandlerRegistry;

package/dist/handlers/findings.js

@@ -0,0 +1,110 @@
+/**
+ * Findings Handlers
+ *
+ * Handles audit findings and knowledge base:
+ * - add_finding
+ * - get_findings
+ * - update_finding
+ * - delete_finding
+ */
+import { validateRequired, validateUUID } from '../validators.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');
+    validateUUID(project_id, 'project_id');
+    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',
+        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 } };
+};
+export const getFindings = async (args, ctx) => {
+    const { project_id, category, severity, status, limit } = 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 } };
+};
+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;
+        }
+    }
+    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 } };
+};
+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 } };
+};
+/**
+ * Findings handlers registry
+ */
+export const findingHandlers = {
+    add_finding: addFinding,
+    get_findings: getFindings,
+    update_finding: updateFinding,
+    delete_finding: deleteFinding,
+};

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

@@ -0,0 +1,22 @@
+/**
+ * Git Issues Handlers
+ *
+ * Handles git-related issue tracking:
+ * - get_git_issues
+ * - create_git_issue
+ * - resolve_git_issue
+ * - dismiss_git_issue
+ */
+import type { Handler, HandlerRegistry } from './types.js';
+export declare const getGitIssues: Handler;
+export declare const createGitIssue: 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>;
+/**
+ * Git Issues handlers registry
+ */
+export declare const gitIssuesHandlers: HandlerRegistry;

package/dist/handlers/git-issues.js

@@ -0,0 +1,247 @@
+/**
+ * Git Issues Handlers
+ *
+ * Handles git-related issue tracking:
+ * - get_git_issues
+ * - create_git_issue
+ * - resolve_git_issue
+ * - dismiss_git_issue
+ */
+import { validateRequired, validateUUID } from '../validators.js';
+export const getGitIssues = async (args, ctx) => {
+    const { project_id, status = 'open', include_resolved = false } = args;
+    validateRequired(project_id, 'project_id');
+    validateUUID(project_id, 'project_id');
+    const { supabase } = ctx;
+    let query = supabase
+        .from('git_issues')
+        .select(`
+			id,
+			task_id,
+			issue_type,
+			severity,
+			branch_name,
+			pr_number,
+			pr_url,
+			target_branch,
+			conflicting_files,
+			error_message,
+			status,
+			created_at,
+			resolved_at,
+			auto_resolved,
+			resolution_note
+		`)
+        .eq('project_id', project_id)
+        .order('created_at', { ascending: false });
+    if (status !== 'all' && !include_resolved) {
+        query = query.eq('status', status);
+    }
+    const { data: issues, error } = await query.limit(50);
+    if (error)
+        throw new Error(`Failed to fetch git issues: ${error.message}`);
+    // Group by severity for summary
+    const summary = {
+        critical: 0,
+        high: 0,
+        medium: 0,
+        low: 0,
+    };
+    const openIssues = (issues || []).filter(i => i.status === 'open');
+    openIssues.forEach(issue => {
+        const sev = issue.severity;
+        if (sev in summary)
+            summary[sev]++;
+    });
+    return {
+        result: {
+            issues: issues || [],
+            open_count: openIssues.length,
+            severity_summary: summary,
+            has_critical: summary.critical > 0,
+            has_blocking: summary.critical > 0 || summary.high > 0,
+        },
+    };
+};
+export const createGitIssue = async (args, ctx) => {
+    const { project_id, task_id, issue_type, severity = 'medium', branch_name, pr_number, pr_url, target_branch, conflicting_files, error_message, } = args;
+    validateRequired(project_id, 'project_id');
+    validateUUID(project_id, 'project_id');
+    validateRequired(issue_type, 'issue_type');
+    const { supabase, session } = ctx;
+    // Check if similar issue already exists (avoid duplicates)
+    if (branch_name || pr_number) {
+        const { data: existing } = await supabase
+            .from('git_issues')
+            .select('id')
+            .eq('project_id', project_id)
+            .eq('status', 'open')
+            .eq('issue_type', issue_type)
+            .or(`branch_name.eq.${branch_name},pr_number.eq.${pr_number}`)
+            .limit(1)
+            .maybeSingle();
+        if (existing) {
+            return {
+                result: {
+                    success: false,
+                    already_exists: true,
+                    existing_issue_id: existing.id,
+                    message: 'A similar git issue already exists for this branch/PR',
+                },
+            };
+        }
+    }
+    const { data: issue, error } = await supabase
+        .from('git_issues')
+        .insert({
+        project_id,
+        task_id: task_id || null,
+        issue_type,
+        severity,
+        branch_name: branch_name || null,
+        pr_number: pr_number || null,
+        pr_url: pr_url || null,
+        target_branch: target_branch || null,
+        conflicting_files: conflicting_files || [],
+        error_message: error_message || null,
+        created_by: 'agent',
+        created_by_session_id: session.currentSessionId,
+    })
+        .select('id, issue_type, severity, branch_name, pr_number')
+        .single();
+    if (error)
+        throw new Error(`Failed to create git issue: ${error.message}`);
+    // Log progress
+    await supabase.from('progress_logs').insert({
+        project_id,
+        task_id: task_id || null,
+        summary: `Git issue created: ${issue_type} on ${branch_name || `PR #${pr_number}`}`,
+        details: error_message || null,
+        created_by: 'agent',
+        created_by_session_id: session.currentSessionId,
+    });
+    return {
+        result: {
+            success: true,
+            issue_id: issue.id,
+            issue_type: issue.issue_type,
+            severity: issue.severity,
+            branch: issue.branch_name,
+            pr_number: issue.pr_number,
+        },
+    };
+};
+export const resolveGitIssue = async (args, ctx) => {
+    const { issue_id, resolution_note, auto_resolved = false } = args;
+    validateRequired(issue_id, 'issue_id');
+    validateUUID(issue_id, 'issue_id');
+    const { supabase, session } = ctx;
+    // Get the issue first
+    const { data: issue, error: fetchError } = await supabase
+        .from('git_issues')
+        .select('id, project_id, task_id, issue_type, branch_name, pr_number, status')
+        .eq('id', issue_id)
+        .single();
+    if (fetchError || !issue)
+        throw new Error('Git issue not found');
+    if (issue.status !== 'open') {
+        return {
+            result: {
+                success: false,
+                error: `Issue is already ${issue.status}`,
+            },
+        };
+    }
+    const { error: updateError } = await supabase
+        .from('git_issues')
+        .update({
+        status: 'resolved',
+        resolved_at: new Date().toISOString(),
+        resolved_by_session_id: session.currentSessionId,
+        auto_resolved,
+        resolution_note: resolution_note || null,
+    })
+        .eq('id', issue_id);
+    if (updateError)
+        throw new Error(`Failed to resolve git issue: ${updateError.message}`);
+    // Log progress
+    await supabase.from('progress_logs').insert({
+        project_id: issue.project_id,
+        task_id: issue.task_id,
+        summary: `Git issue resolved: ${issue.issue_type} on ${issue.branch_name || `PR #${issue.pr_number}`}${auto_resolved ? ' (auto)' : ''}`,
+        details: resolution_note || null,
+        created_by: 'agent',
+        created_by_session_id: session.currentSessionId,
+    });
+    return {
+        result: {
+            success: true,
+            resolved_issue_id: issue_id,
+            auto_resolved,
+        },
+    };
+};
+export const dismissGitIssue = async (args, ctx) => {
+    const { issue_id, reason } = args;
+    validateRequired(issue_id, 'issue_id');
+    validateUUID(issue_id, 'issue_id');
+    const { supabase, session } = ctx;
+    const { error } = await supabase
+        .from('git_issues')
+        .update({
+        status: 'dismissed',
+        resolved_at: new Date().toISOString(),
+        resolved_by_session_id: session.currentSessionId,
+        resolution_note: reason || 'Dismissed',
+    })
+        .eq('id', issue_id);
+    if (error)
+        throw new Error(`Failed to dismiss git issue: ${error.message}`);
+    return {
+        result: {
+            success: true,
+            dismissed_issue_id: issue_id,
+        },
+    };
+};
+/**
+ * Auto-resolve git issues for a branch when it becomes mergeable
+ */
+export async function autoResolveGitIssuesForBranch(supabase, projectId, branchName, sessionId) {
+    const { data: issues } = await supabase
+        .from('git_issues')
+        .select('id')
+        .eq('project_id', projectId)
+        .eq('branch_name', branchName)
+        .eq('status', 'open')
+        .in('issue_type', ['merge_conflict', 'rebase_needed']);
+    if (!issues || issues.length === 0)
+        return 0;
+    const { error } = await supabase
+        .from('git_issues')
+        .update({
+        status: 'resolved',
+        resolved_at: new Date().toISOString(),
+        resolved_by_session_id: sessionId,
+        auto_resolved: true,
+        resolution_note: 'Auto-resolved: branch is now mergeable',
+    })
+        .eq('project_id', projectId)
+        .eq('branch_name', branchName)
+        .eq('status', 'open')
+        .in('issue_type', ['merge_conflict', 'rebase_needed']);
+    if (error) {
+        console.error('Failed to auto-resolve git issues:', error);
+        return 0;
+    }
+    return issues.length;
+}
+/**
+ * Git Issues handlers registry
+ */
+export const gitIssuesHandlers = {
+    get_git_issues: getGitIssues,
+    create_git_issue: createGitIssue,
+    resolve_git_issue: resolveGitIssue,
+    dismiss_git_issue: dismissGitIssue,
+};

package/dist/handlers/ideas.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Ideas Handlers
+ *
+ * Handles feature ideas tracking:
+ * - add_idea
+ * - update_idea
+ * - get_ideas
+ * - delete_idea
+ */
+import type { Handler, HandlerRegistry } from './types.js';
+export declare const addIdea: Handler;
+export declare const updateIdea: Handler;
+export declare const getIdeas: Handler;
+export declare const deleteIdea: Handler;
+export declare const convertIdeaToTask: Handler;
+/**
+ * Ideas handlers registry
+ */
+export declare const ideaHandlers: HandlerRegistry;