@vibescope/mcp-server 0.0.1

package/dist/handlers/progress.js

@@ -0,0 +1,149 @@
+/**
+ * Progress Handlers
+ *
+ * Handles progress logging and activity feed:
+ * - log_progress
+ * - get_activity_feed
+ */
+import { validateRequired, validateUUID } from '../validators.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,
+        summary,
+        details: details || null,
+        created_by: 'agent',
+        created_by_session_id: session.currentSessionId,
+    });
+    if (error)
+        throw new Error(`Failed to log progress: ${error.message}`);
+    return { result: { success: true } };
+};
+export const getActivityFeed = async (args, ctx) => {
+    const { project_id, types, created_by, since, limit = 50 } = args;
+    validateRequired(project_id, 'project_id');
+    validateUUID(project_id, 'project_id');
+    const { supabase } = ctx;
+    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,
+                });
+            }
+        }
+    }
+    // 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 } };
+};
+/**
+ * Progress handlers registry
+ */
+export const progressHandlers = {
+    log_progress: logProgress,
+    get_activity_feed: getActivityFeed,
+};

package/dist/handlers/project.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Project Handlers
+ *
+ * Handles project CRUD and configuration:
+ * - get_project_context
+ * - get_git_workflow
+ * - create_project
+ * - update_project
+ * - update_project_readme
+ */
+import type { Handler, HandlerRegistry } from './types.js';
+export declare const getProjectContext: Handler;
+export declare const getGitWorkflow: Handler;
+export declare const createProject: Handler;
+export declare const updateProject: Handler;
+export declare const updateProjectReadme: Handler;
+/**
+ * Project handlers registry
+ */
+export declare const projectHandlers: HandlerRegistry;

package/dist/handlers/project.js

@@ -0,0 +1,278 @@
+/**
+ * Project Handlers
+ *
+ * Handles project CRUD and configuration:
+ * - get_project_context
+ * - get_git_workflow
+ * - create_project
+ * - update_project
+ * - 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 };
+}
+export const getProjectContext = async (args, ctx) => {
+    const { project_id, git_url } = args;
+    const { supabase, auth, session } = ctx;
+    // 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 || [] } };
+    }
+    // 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 { data: project, error: projectError } = await query.single();
+    if (projectError || !project) {
+        return {
+            result: {
+                found: false,
+                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 };
+};
+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;
+    }
+    // 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 };
+};
+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,
+        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 } };
+};
+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 } };
+};
+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 } };
+};
+/**
+ * Project handlers registry
+ */
+export const projectHandlers = {
+    get_project_context: getProjectContext,
+    get_git_workflow: getGitWorkflow,
+    create_project: createProject,
+    update_project: updateProject,
+    update_project_readme: updateProjectReadme,
+};

package/dist/handlers/requests.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Requests Handlers
+ *
+ * Handles user request handling:
+ * - get_pending_requests
+ * - acknowledge_request
+ * - answer_question
+ */
+import type { Handler, HandlerRegistry } from './types.js';
+export declare const getPendingRequests: Handler;
+export declare const acknowledgeRequest: Handler;
+export declare const answerQuestion: Handler;
+/**
+ * Requests handlers registry
+ */
+export declare const requestHandlers: HandlerRegistry;

package/dist/handlers/requests.js

@@ -0,0 +1,131 @@
+/**
+ * Requests Handlers
+ *
+ * Handles user request handling:
+ * - get_pending_requests
+ * - acknowledge_request
+ * - answer_question
+ */
+import { validateRequired, validateUUID } from '../validators.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;
+    return {
+        result: {
+            requests: sortedRequests,
+            count: sortedRequests.length,
+            questions_count: questionsCount,
+        },
+    };
+};
+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;
+    return {
+        result: {
+            success: true,
+            request,
+        },
+    };
+};
+export const answerQuestion = async (args, ctx) => {
+    const { request_id, answer } = args;
+    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;
+    return {
+        result: {
+            success: true,
+            message: 'Question answered successfully',
+            request,
+        },
+    };
+};
+/**
+ * Requests handlers registry
+ */
+export const requestHandlers = {
+    get_pending_requests: getPendingRequests,
+    acknowledge_request: acknowledgeRequest,
+    answer_question: answerQuestion,
+};

package/dist/handlers/roles.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Role Handlers
+ *
+ * Manages agent roles for specialized work:
+ * - get_role_settings: Get role configuration for a project
+ * - update_role_settings: Update role settings
+ * - set_session_role: Change the current session's role
+ * - get_agents_by_role: Get active agents grouped by role
+ */
+import type { Handler, HandlerRegistry } from './types.js';
+/**
+ * Get role settings for a project
+ */
+export declare const getRoleSettings: Handler;
+/**
+ * Update role settings for a project
+ */
+export declare const updateRoleSettings: Handler;
+/**
+ * Set the current session's role
+ */
+export declare const setSessionRole: Handler;
+/**
+ * Get active agents grouped by role
+ */
+export declare const getAgentsByRole: Handler;
+/**
+ * Role handlers registry
+ */
+export declare const roleHandlers: HandlerRegistry;