@vibescope/mcp-server 0.0.1 → 0.2.0

package/dist/handlers/knowledge.js

@@ -1,108 +0,0 @@
-/**
- * Knowledge Handlers
- *
- * Unified knowledge query to reduce tool calls and token costs.
- * Aggregates decisions, findings, blockers, Q&A, and task history.
- */
-import { validateRequired, validateUUID } from '../validators.js';
-const VALID_QUERY_TYPES = ['context', 'architecture', 'issues', 'history', 'qa'];
-const QUERY_TYPE_DESCRIPTIONS = {
-    context: 'Key decisions, open blockers, recent Q&As, critical findings - use when starting work',
-    architecture: 'All decisions + architecture-related findings - use when understanding codebase',
-    issues: 'Open findings + blockers sorted by severity - use when fixing bugs',
-    history: 'Completed tasks with summaries - use when understanding what was done',
-    qa: 'Answered questions as Q&A pairs - use when looking for common questions',
-};
-export const queryKnowledge = async (args, ctx) => {
-    const { project_id, query_type = 'context', limit = 20 } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    if (!VALID_QUERY_TYPES.includes(query_type)) {
-        throw new Error(`Invalid query_type '${query_type}'. Must be one of: ${VALID_QUERY_TYPES.join(', ')}`);
-    }
-    const { supabase } = ctx;
-    // Call the database function
-    const { data, error } = await supabase.rpc('query_knowledge', {
-        p_project_id: project_id,
-        p_query_type: query_type,
-        p_limit: Math.min(limit, 50), // Cap at 50 to limit response size
-    });
-    if (error) {
-        throw new Error(`Failed to query knowledge: ${error.message}`);
-    }
-    // Map database results to typed items
-    const items = (data || []).map((row) => ({
-        type: row.item_type,
-        id: row.id,
-        title: row.title,
-        content: row.content,
-        ...(row.severity && { severity: row.severity }),
-        ...(row.status && { status: row.status }),
-        created_at: row.created_at,
-    }));
-    // Generate summary based on query type and results
-    const summary = generateSummary(query_type, items);
-    // Estimate tokens (rough: ~4 chars per token)
-    const responseJson = JSON.stringify({ items, summary });
-    const tokenEstimate = Math.ceil(responseJson.length / 4);
-    return {
-        result: {
-            query_type,
-            project_id,
-            description: QUERY_TYPE_DESCRIPTIONS[query_type],
-            summary,
-            items,
-            count: items.length,
-            token_estimate: tokenEstimate,
-        },
-    };
-};
-function generateSummary(queryType, items) {
-    const counts = items.reduce((acc, item) => {
-        acc[item.type] = (acc[item.type] || 0) + 1;
-        return acc;
-    }, {});
-    const parts = [];
-    switch (queryType) {
-        case 'context':
-            if (counts.blocker)
-                parts.push(`${counts.blocker} open blocker(s)`);
-            if (counts.finding)
-                parts.push(`${counts.finding} critical/high finding(s)`);
-            if (counts.decision)
-                parts.push(`${counts.decision} recent decision(s)`);
-            if (counts.qa)
-                parts.push(`${counts.qa} answered question(s)`);
-            break;
-        case 'architecture':
-            if (counts.decision)
-                parts.push(`${counts.decision} architectural decision(s)`);
-            if (counts.finding)
-                parts.push(`${counts.finding} architecture finding(s)`);
-            break;
-        case 'issues':
-            if (counts.blocker)
-                parts.push(`${counts.blocker} blocker(s)`);
-            if (counts.finding)
-                parts.push(`${counts.finding} open finding(s)`);
-            break;
-        case 'history':
-            if (counts.task)
-                parts.push(`${counts.task} completed task(s)`);
-            break;
-        case 'qa':
-            if (counts.qa)
-                parts.push(`${counts.qa} Q&A pair(s)`);
-            break;
-    }
-    if (parts.length === 0) {
-        return `No ${queryType} items found.`;
-    }
-    return `Found ${parts.join(', ')}.`;
-}
-/**
- * Knowledge handlers registry
- */
-export const knowledgeHandlers = {
-    query_knowledge: queryKnowledge,
-};

package/dist/handlers/roles.d.ts

@@ -1,30 +0,0 @@
-/**
- * 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;

package/dist/handlers/roles.js

@@ -1,281 +0,0 @@
-/**
- * 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 { validateUUID, validateRequired } from '../validators.js';
-// Valid agent roles - must match AgentRole type in types.ts and database enum
-const VALID_ROLES = ['developer', 'validator', 'deployer', 'reviewer', 'maintainer'];
-function isValidRole(role) {
-    return VALID_ROLES.includes(role);
-}
-/**
- * Verify the user owns or has access to the project
- * This is needed because MCP server uses service_role which bypasses RLS
- */
-async function verifyProjectAccess(ctx, projectId) {
-    const { supabase, auth } = ctx;
-    // Check if user owns the project
-    const { data: ownedProject } = await supabase
-        .from('projects')
-        .select('id')
-        .eq('id', projectId)
-        .eq('user_id', auth.userId)
-        .single();
-    if (ownedProject)
-        return;
-    // Check if project is shared with user's organization (for org-scoped keys)
-    if (auth.scope === 'organization' && auth.organizationId) {
-        const { data: sharedProject } = await supabase
-            .from('project_shares')
-            .select('project_id')
-            .eq('project_id', projectId)
-            .eq('organization_id', auth.organizationId)
-            .single();
-        if (sharedProject)
-            return;
-    }
-    throw new Error('Project not found or access denied');
-}
-/**
- * Get role settings for a project
- */
-export const getRoleSettings = async (args, ctx) => {
-    const { project_id } = args;
-    const { supabase } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    // Verify user has access to this project
-    await verifyProjectAccess(ctx, project_id);
-    const { data: settings, error } = await supabase
-        .from('project_role_settings')
-        .select('*')
-        .eq('project_id', project_id)
-        .order('role');
-    if (error) {
-        throw new Error(`Failed to get role settings: ${error.message}`);
-    }
-    // If no settings exist, return defaults
-    if (!settings || settings.length === 0) {
-        return {
-            result: {
-                project_id,
-                settings: VALID_ROLES.map(role => ({
-                    role,
-                    enabled: true,
-                    display_name: role.charAt(0).toUpperCase() + role.slice(1),
-                    description: getRoleDescription(role),
-                })),
-                note: 'Using default settings. Call update_role_settings to customize.',
-            },
-        };
-    }
-    return {
-        result: {
-            project_id,
-            settings,
-        },
-    };
-};
-function getRoleDescription(role) {
-    const descriptions = {
-        developer: 'General development work, picks up any available task',
-        validator: 'Focuses on validating completed tasks',
-        deployer: 'Handles deployment coordination and monitoring',
-        reviewer: 'Code review and quality checks',
-        maintainer: 'Task management, git orchestration, housekeeping',
-    };
-    return descriptions[role];
-}
-/**
- * Update role settings for a project
- */
-export const updateRoleSettings = async (args, ctx) => {
-    const { project_id, role, enabled, display_name, description, priority_filter, fallback_activities, auto_assign_validation, auto_assign_deployment, } = args;
-    const { supabase } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(role, 'role');
-    if (!isValidRole(role)) {
-        throw new Error(`Invalid role: ${role}. Valid roles: ${VALID_ROLES.join(', ')}`);
-    }
-    // Verify user has access to this project
-    await verifyProjectAccess(ctx, project_id);
-    const updates = {
-        updated_at: new Date().toISOString(),
-    };
-    if (enabled !== undefined)
-        updates.enabled = enabled;
-    if (display_name !== undefined)
-        updates.display_name = display_name;
-    if (description !== undefined)
-        updates.description = description;
-    if (priority_filter !== undefined)
-        updates.priority_filter = priority_filter;
-    if (fallback_activities !== undefined)
-        updates.fallback_activities = fallback_activities;
-    if (auto_assign_validation !== undefined)
-        updates.auto_assign_validation = auto_assign_validation;
-    if (auto_assign_deployment !== undefined)
-        updates.auto_assign_deployment = auto_assign_deployment;
-    // Upsert the role settings
-    const { data, error } = await supabase
-        .from('project_role_settings')
-        .upsert({
-        project_id,
-        role,
-        ...updates,
-    }, {
-        onConflict: 'project_id,role',
-    })
-        .select()
-        .single();
-    if (error) {
-        throw new Error(`Failed to update role settings: ${error.message}`);
-    }
-    return {
-        result: {
-            success: true,
-            settings: data,
-        },
-    };
-};
-/**
- * Set the current session's role
- */
-export const setSessionRole = async (args, ctx) => {
-    const { role, role_config } = args;
-    const { supabase, session, updateSession } = ctx;
-    validateRequired(role, 'role');
-    if (!isValidRole(role)) {
-        throw new Error(`Invalid role: ${role}. Valid roles: ${VALID_ROLES.join(', ')}`);
-    }
-    const sessionId = session.currentSessionId;
-    if (!sessionId) {
-        throw new Error('No active session. Call start_work_session first.');
-    }
-    const updates = {
-        role,
-        updated_at: new Date().toISOString(),
-    };
-    // Allow role_config for custom configurations (e.g., maintainer with specific focus areas)
-    if (role_config) {
-        updates.role_config = role_config;
-    }
-    const { error } = await supabase
-        .from('agent_sessions')
-        .update(updates)
-        .eq('id', sessionId);
-    if (error) {
-        throw new Error(`Failed to set role: ${error.message}`);
-    }
-    // Update session state
-    updateSession({ currentRole: role });
-    // Get role-specific guidance
-    const guidance = getRoleGuidance(role);
-    return {
-        result: {
-            success: true,
-            role,
-            persona: session.currentPersona,
-            guidance,
-        },
-    };
-};
-function getRoleGuidance(role) {
-    const guidance = {
-        developer: 'Focus on implementing features and fixing bugs. Use get_next_task to find work.',
-        validator: 'Prioritize validation tasks. Use get_tasks_awaiting_validation to find completed tasks to review.',
-        deployer: 'Monitor deployment status with check_deployment_status. Handle deployment requests and coordination.',
-        reviewer: 'Run code reviews using code_review fallback activity. Check for security and quality issues.',
-        maintainer: 'Handle task management, git orchestration. Run performance_audit, dependency_audit when idle.',
-    };
-    return guidance[role];
-}
-/**
- * Get active agents grouped by role
- */
-export const getAgentsByRole = async (args, ctx) => {
-    const { project_id } = args;
-    const { supabase } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    // Verify user has access to this project
-    await verifyProjectAccess(ctx, project_id);
-    const { data: agents, error } = await supabase
-        .from('agent_sessions')
-        .select(`
-			id,
-			agent_name,
-			role,
-			status,
-			current_task_id,
-			last_synced_at,
-			role_config
-		`)
-        .eq('project_id', project_id)
-        .neq('status', 'disconnected')
-        .gte('last_synced_at', new Date(Date.now() - 5 * 60 * 1000).toISOString());
-    if (error) {
-        throw new Error(`Failed to get agents: ${error.message}`);
-    }
-    // Group by role
-    const byRole = {};
-    for (const agent of agents || []) {
-        const role = agent.role || 'developer';
-        if (!byRole[role]) {
-            byRole[role] = [];
-        }
-        byRole[role].push(agent);
-    }
-    // Get current task titles
-    const taskIds = (agents || [])
-        .map(a => a.current_task_id)
-        .filter((id) => !!id);
-    let taskTitles = {};
-    if (taskIds.length > 0) {
-        const { data: tasks } = await supabase
-            .from('tasks')
-            .select('id, title')
-            .in('id', taskIds);
-        taskTitles = (tasks || []).reduce((acc, t) => {
-            acc[t.id] = t.title;
-            return acc;
-        }, {});
-    }
-    // Enrich agents with task titles
-    const enrichedByRole = {};
-    for (const [role, roleAgents] of Object.entries(byRole)) {
-        enrichedByRole[role] = roleAgents.map(agent => ({
-            id: agent.id,
-            agent_name: agent.agent_name,
-            role: agent.role || 'developer',
-            status: agent.status,
-            current_task: agent.current_task_id
-                ? { id: agent.current_task_id, title: taskTitles[agent.current_task_id] || 'Unknown' }
-                : null,
-            last_synced_at: agent.last_synced_at,
-        }));
-    }
-    return {
-        result: {
-            project_id,
-            total_agents: agents?.length || 0,
-            by_role: enrichedByRole,
-            available_roles: VALID_ROLES,
-        },
-    };
-};
-/**
- * Role handlers registry
- */
-export const roleHandlers = {
-    get_role_settings: getRoleSettings,
-    update_role_settings: updateRoleSettings,
-    set_session_role: setSessionRole,
-    get_agents_by_role: getAgentsByRole,
-};

package/dist/handlers/tasks.test.d.ts

@@ -1 +0,0 @@
-export {};