@rigstate/mcp 0.4.2

package/src/tools/pending-tasks.ts

@@ -0,0 +1,228 @@
+/**
+ * Tool: get_pending_tasks
+ * 
+ * Gets tasks from the agent_bridge table that have been APPROVED by the user
+ * and are ready for Frank to execute. Also includes update_task_status for 
+ * marking tasks as EXECUTING or COMPLETED.
+ */
+
+import { SupabaseClient } from '@supabase/supabase-js';
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+export interface PendingTask {
+    id: string;
+    project_id: string;
+    task_id: string | null; // Reference to roadmap_chunks
+    status: string;
+    objective: string; // Mapped from proposal or roadmap_chunks.title
+    technical_context: string; // Mapped from roadmap_chunks.prompt_content
+    constraints: string[]; // Extracted from verification_criteria
+    definition_of_done: string; // Mapped from verification_criteria
+    created_at: string;
+}
+
+export interface GetPendingTasksResponse {
+    success: boolean;
+    tasks: PendingTask[];
+    message: string;
+}
+
+export interface UpdateTaskStatusResponse {
+    success: boolean;
+    task_id: string;
+    previous_status: string;
+    new_status: string;
+    message: string;
+}
+
+// =============================================================================
+// GET PENDING TASKS
+// =============================================================================
+
+/**
+ * Fetches tasks that have been APPROVED by the user through the dashboard
+ * and are ready for the AI agent (Frank) to execute.
+ */
+export async function getPendingTasks(
+    supabase: SupabaseClient,
+    projectId: string
+): Promise<GetPendingTasksResponse> {
+
+    // Fetch APPROVED tasks that are ready for execution
+    const { data: tasks, error } = await supabase
+        .from('agent_bridge')
+        .select(`
+            id,
+            project_id,
+            task_id,
+            status,
+            proposal,
+            summary,
+            created_at,
+            roadmap_chunks (
+                title,
+                prompt_content,
+                verification_criteria,
+                summary
+            )
+        `)
+        .eq('project_id', projectId)
+        .eq('status', 'APPROVED')
+        .order('created_at', { ascending: true });
+
+    if (error) {
+        throw new Error(`Failed to fetch pending tasks: ${error.message}`);
+    }
+
+    if (!tasks || tasks.length === 0) {
+        return {
+            success: true,
+            tasks: [],
+            message: 'No approved tasks waiting for execution. 🎉'
+        };
+    }
+
+    // Transform to the expected format
+    const pendingTasks: PendingTask[] = tasks.map((task: any) => {
+        const roadmap = task.roadmap_chunks;
+
+        // Extract constraints from verification_criteria if available
+        let constraints: string[] = [];
+        let definitionOfDone = 'Complete the task as described.';
+
+        if (roadmap?.verification_criteria) {
+            const criteria = roadmap.verification_criteria;
+            if (typeof criteria === 'string') {
+                definitionOfDone = criteria;
+                // Try to extract bullet-point constraints
+                constraints = criteria
+                    .split('\n')
+                    .filter((line: string) => line.trim().startsWith('-') || line.trim().startsWith('•'))
+                    .map((line: string) => line.replace(/^[-•]\s*/, '').trim());
+            } else if (Array.isArray(criteria)) {
+                constraints = criteria;
+                definitionOfDone = criteria.join('\n');
+            }
+        }
+
+        return {
+            id: task.id,
+            project_id: task.project_id,
+            task_id: task.task_id,
+            status: task.status,
+            objective: task.proposal || roadmap?.title || task.summary || 'Unnamed Task',
+            technical_context: roadmap?.prompt_content || roadmap?.summary || 'No additional context provided.',
+            constraints: constraints,
+            definition_of_done: definitionOfDone,
+            created_at: task.created_at
+        };
+    });
+
+    return {
+        success: true,
+        tasks: pendingTasks,
+        message: `Found ${pendingTasks.length} approved task(s) ready for execution.`
+    };
+}
+
+// =============================================================================
+// UPDATE TASK STATUS
+// =============================================================================
+
+/**
+ * Updates the status of an agent_bridge task.
+ * Allowed transitions:
+ * - APPROVED → EXECUTING (when Frank starts working)
+ * - EXECUTING → COMPLETED (when Frank finishes successfully)
+ * - EXECUTING → FAILED (if something goes wrong)
+ * 
+ * Also updates the linked roadmap_chunk if the task is COMPLETED.
+ */
+export async function updateTaskStatus(
+    supabase: SupabaseClient,
+    projectId: string,
+    taskId: string,
+    newStatus: 'EXECUTING' | 'COMPLETED' | 'FAILED',
+    executionSummary?: string
+): Promise<UpdateTaskStatusResponse> {
+
+    // 1. Fetch the current task state
+    const { data: currentTask, error: fetchError } = await supabase
+        .from('agent_bridge')
+        .select('status, task_id')
+        .eq('id', taskId)
+        .eq('project_id', projectId)
+        .single();
+
+    if (fetchError || !currentTask) {
+        throw new Error(`Task not found: ${taskId}`);
+    }
+
+    const previousStatus = currentTask.status;
+
+    // 2. Validate state transition
+    const validTransitions: Record<string, string[]> = {
+        'APPROVED': ['EXECUTING'],
+        'EXECUTING': ['COMPLETED', 'FAILED']
+    };
+
+    if (!validTransitions[previousStatus]?.includes(newStatus)) {
+        throw new Error(
+            `Invalid status transition: ${previousStatus} → ${newStatus}. ` +
+            `Allowed from ${previousStatus}: ${validTransitions[previousStatus]?.join(', ') || 'none'}`
+        );
+    }
+
+    // 3. Build update payload
+    const updateData: Record<string, any> = {
+        status: newStatus,
+        updated_at: new Date().toISOString()
+    };
+
+    if (newStatus === 'COMPLETED') {
+        if (!executionSummary) {
+            throw new Error('execution_summary is REQUIRED when setting status to COMPLETED.');
+        }
+        updateData.execution_summary = executionSummary;
+        updateData.completed_at = new Date().toISOString();
+    } else if (executionSummary) {
+        updateData.summary = executionSummary;
+    }
+
+    // 4. Update the agent_bridge task
+    const { error: updateError } = await supabase
+        .from('agent_bridge')
+        .update(updateData)
+        .eq('id', taskId)
+        .eq('project_id', projectId);
+
+    if (updateError) {
+        throw new Error(`Failed to update task status: ${updateError.message}`);
+    }
+
+    // 5. If COMPLETED, also mark the roadmap_chunk as COMPLETED
+    if (newStatus === 'COMPLETED' && currentTask.task_id) {
+        const { error: roadmapError } = await supabase
+            .from('roadmap_chunks')
+            .update({
+                status: 'COMPLETED',
+                completed_at: new Date().toISOString()
+            })
+            .eq('id', currentTask.task_id);
+
+        if (roadmapError) {
+            console.error(`Warning: Failed to update roadmap_chunk status: ${roadmapError.message}`);
+        }
+    }
+
+    return {
+        success: true,
+        task_id: taskId,
+        previous_status: previousStatus,
+        new_status: newStatus,
+        message: `Task ${taskId} status updated from ${previousStatus} → ${newStatus}.`
+    };
+}

package/src/tools/planning-tools.ts

@@ -0,0 +1,123 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { SaveToProjectBrainInput, UpdateRoadmapStatusInput, AddRoadmapChunkInput } from '../lib/types.js';
+
+/**
+ * Maja's Tool: Save to Project Brain
+ * Persists knowledge, decisions, and notes.
+ */
+export async function saveToProjectBrain(
+    supabase: SupabaseClient,
+    userId: string,
+    input: SaveToProjectBrainInput
+) {
+    const { projectId, title, content, category, tags } = input;
+
+    // Confirm project access
+    const { data: p, error: pErr } = await supabase.from('projects').select('id').eq('id', projectId).eq('owner_id', userId).single();
+    if (pErr || !p) throw new Error('Access denied');
+
+    const fullContent = `# ${title}\n\n${content}`;
+
+    const { data, error } = await supabase
+        .from('project_memories')
+        .insert({
+            project_id: projectId,
+            content: fullContent,
+            category: category.toLowerCase(),
+            tags: tags,
+            importance: (category === 'DECISION' || category === 'ARCHITECTURE') ? 9 : 5,
+            is_active: true,
+            source_type: 'chat_manual'
+        })
+        .select('id')
+        .single();
+
+    if (error) throw new Error(`Failed to save memory: ${error.message}`);
+
+    return {
+        success: true,
+        memoryId: data.id,
+        message: `✅ Saved [${category}] "${title}" to Project Brain.`
+    };
+}
+
+/**
+ * Kine's Tool: Update Roadmap Status
+ * Updates task status and notifies Scribe system.
+ */
+export async function updateRoadmapStatus(
+    supabase: SupabaseClient,
+    userId: string,
+    input: UpdateRoadmapStatusInput
+) {
+    const { projectId, chunkId, status } = input;
+
+    // Map status to DB enum: 'TODO' -> 'LOCKED' (Standard convention in Rigstate seems to be LOCKED/ACTIVE/COMPLETED)
+    // If 'TODO' is meant to be 'PENDING', we check schema. Assuming 'LOCKED' is the backlog state.
+    const dbStatus = status === 'TODO' ? 'LOCKED' : status === 'IN_PROGRESS' ? 'ACTIVE' : 'COMPLETED';
+
+    const { error } = await supabase
+        .from('roadmap_chunks')
+        .update({ status: dbStatus })
+        .eq('id', chunkId)
+        .eq('project_id', projectId);
+
+    if (error) throw new Error(`Update failed: ${error.message}`);
+
+    let message = `Roadmap status updated to ${status} (${dbStatus}).`;
+
+    if (status === 'COMPLETED') {
+        // "Notification" to Gunhild
+        message += " 📢 Gunhild (Scribe) has been signaled. This completion will be reflected in the next report.";
+    } else if (status === 'IN_PROGRESS') {
+        message += " 🚀 Work started.";
+    }
+
+    return { success: true, status: dbStatus, message };
+}
+
+/**
+ * Kine's Tool: Add Roadmap Chunk
+ * Decomposes features into actionable chunks.
+ */
+export async function addRoadmapChunk(
+    supabase: SupabaseClient,
+    userId: string,
+    input: AddRoadmapChunkInput
+) {
+    const { projectId, title, description, priority } = input;
+
+    // Get max step number
+    const { data: maxStep } = await supabase
+        .from('roadmap_chunks')
+        .select('step_number')
+        .eq('project_id', projectId)
+        .order('step_number', { ascending: false })
+        .limit(1)
+        .single();
+
+    const nextStepNum = (maxStep?.step_number || 0) + 1;
+
+    const { data, error } = await supabase
+        .from('roadmap_chunks')
+        .insert({
+            project_id: projectId,
+            title: title,
+            description: description || '',
+            status: 'LOCKED', // Default state
+            priority: priority,
+            step_number: nextStepNum,
+            sprint_focus: input.featureId ? `Feature: ${input.featureId}` : null
+        })
+        .select('id')
+        .single();
+
+    if (error) throw new Error(`Failed to add chunk: ${error.message}`);
+
+    return {
+        success: true,
+        chunkId: data.id,
+        stepNumber: nextStepNum,
+        message: `✅ Added new roadmap chunk: "${title}" (Step ${nextStepNum}).`
+    };
+}

package/src/tools/query-brain.ts

@@ -0,0 +1,125 @@
+/**
+ * Tool: query_brain
+ * 
+ * Takes a natural language query and performs semantic search
+ * against the project's memories (RAG), returning relevant
+ * architecture rules, decisions, and constraints.
+ */
+
+import { SupabaseClient } from '@supabase/supabase-js';
+import type { BrainQueryResponse, MemoryRecord } from '../lib/types.js';
+
+// Simple embedding generation using text normalization
+// In production, this would call an embedding API like OpenAI
+async function generateQueryEmbedding(query: string): Promise<number[]> {
+    // For MCP server, we'll use the match_memories_text RPC if available,
+    // or fall back to keyword-based search.
+    // This is a placeholder - the actual embedding should be done via the Supabase edge function
+    // or passed through to the main Rigstate API.
+
+    // For now, return null to trigger keyword fallback
+    return [];
+}
+
+export async function queryBrain(
+    supabase: SupabaseClient,
+    userId: string,
+    projectId: string,
+    query: string,
+    limit: number = 8,
+    threshold: number = 0.5
+): Promise<BrainQueryResponse> {
+    // First, verify project ownership
+    const { data: project, error: projectError } = await supabase
+        .from('projects')
+        .select('id')
+        .eq('id', projectId)
+        .eq('owner_id', userId)
+        .single();
+
+    if (projectError || !project) {
+        throw new Error('Project not found or access denied');
+    }
+
+    // Try semantic search first using the match_memories RPC
+    // This requires the embedding to be generated, so we'll try
+    // a text-based search as fallback
+    let memories: MemoryRecord[] = [];
+
+    // Attempt keyword-based search using ilike on content
+    // This is a simpler approach that works without embeddings
+    const searchTerms = query.toLowerCase().split(/\s+/).filter(t => t.length > 2);
+
+    if (searchTerms.length > 0) {
+        // Build OR condition for fuzzy matching
+        const orConditions = searchTerms.map(term => `content.ilike.%${term}%`).join(',');
+
+        const { data: keywordMatches, error: searchError } = await supabase
+            .from('project_memories')
+            .select('id, content, category, tags, net_votes, created_at')
+            .eq('project_id', projectId)
+            .eq('is_active', true)
+            .or(orConditions)
+            .order('net_votes', { ascending: false, nullsFirst: false })
+            .limit(limit);
+
+        if (!searchError && keywordMatches) {
+            memories = keywordMatches.map(m => ({
+                id: m.id,
+                content: m.content,
+                category: m.category || 'general',
+                tags: m.tags || [],
+                netVotes: m.net_votes,
+                createdAt: m.created_at
+            }));
+        }
+    }
+
+    // If no keyword matches, fetch recent memories
+    if (memories.length === 0) {
+        const { data: recentMemories, error: recentError } = await supabase
+            .from('project_memories')
+            .select('id, content, category, tags, net_votes, created_at')
+            .eq('project_id', projectId)
+            .eq('is_active', true)
+            .order('created_at', { ascending: false })
+            .limit(limit);
+
+        if (!recentError && recentMemories) {
+            memories = recentMemories.map(m => ({
+                id: m.id,
+                content: m.content,
+                category: m.category || 'general',
+                tags: m.tags || [],
+                netVotes: m.net_votes,
+                createdAt: m.created_at
+            }));
+        }
+    }
+
+    // Format memories into a readable context block
+    const contextLines = memories.map((m) => {
+        const voteIndicator = m.netVotes && m.netVotes < 0 ? ` [⚠️ POORLY RATED: ${m.netVotes}]` : '';
+        const tagStr = m.tags.length > 0 ? ` [${m.tags.join(', ')}]` : '';
+        return `- [${m.category.toUpperCase()}]${tagStr}${voteIndicator}: ${m.content}`;
+    });
+
+    const formatted = memories.length > 0
+        ? `=== PROJECT BRAIN: RELEVANT MEMORIES ===
+Query: "${query}"
+Found ${memories.length} relevant memories:
+
+${contextLines.join('\n')}
+
+==========================================`
+        : `=== PROJECT BRAIN ===
+Query: "${query}"
+No relevant memories found for this query.
+=======================`;
+
+    return {
+        query,
+        memories,
+        formatted
+    };
+}

package/src/tools/research-tools.ts

@@ -0,0 +1,149 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { QueryProjectBrainInput, FetchPackageHealthInput } from '../lib/types.js';
+
+/**
+ * Maja's Tool: Project Brain Query
+ * Searches for ADRs, architecture decisions, and memories with a focus on "Why".
+ */
+export async function queryProjectBrain(
+    supabase: SupabaseClient,
+    userId: string,
+    input: QueryProjectBrainInput
+) {
+    const { projectId, query, limit = 5 } = input;
+
+    // Verify access
+    const { data: project, error: pError } = await supabase
+        .from('projects')
+        .select('id')
+        .eq('id', projectId)
+        .eq('owner_id', userId)
+        .single();
+
+    if (pError || !project) throw new Error('Access denied or project not found');
+
+    // Simple keyword search
+    const terms = query.toLowerCase().split(/\s+/).filter(t => t.length > 2);
+
+    let queryBuilder = supabase
+        .from('project_memories')
+        .select('id, content, category, tags, importance, created_at')
+        .eq('project_id', projectId)
+        .eq('is_active', true);
+
+    if (terms.length > 0) {
+        // Search content. 
+        // Ideally we search tags too, but PostgREST filter for array-contains-text-ILIKE is complex.
+        // We rely on content search, which includes the Title (markdown header) and body.
+        const orParams = terms.map(t => `content.ilike.%${t}%`).join(',');
+        queryBuilder = queryBuilder.or(orParams);
+    }
+
+    const { data, error } = await queryBuilder
+        .order('importance', { ascending: false }) // Prioritize High Importance (ADRs)
+        .order('created_at', { ascending: false })
+        .limit(limit);
+
+    if (error) throw new Error(`Brain query failed: ${error.message}`);
+
+    const results = (data || []).map(m => ({
+        id: m.id,
+        category: m.category,
+        tags: m.tags,
+        importance: m.importance,
+        preview: m.content.substring(0, 200) + '...',
+        fullContent: m.content,
+        date: new Date(m.created_at).toLocaleDateString()
+    }));
+
+    return {
+        query,
+        matchCount: results.length,
+        results
+    };
+}
+
+/**
+ * Astrid's Tool: NPM Package Health Check
+ * Evaluates a library's maturity and safety.
+ */
+export async function fetchPackageHealth(input: FetchPackageHealthInput) {
+    const { packageName } = input;
+
+    try {
+        // 1. Registry Metadata
+        const res = await fetch(`https://registry.npmjs.org/${packageName}`);
+        if (!res.ok) {
+            if (res.status === 404) return { status: 'NOT_FOUND', message: 'Package does not exist.' };
+            throw new Error(`Registry error: ${res.statusText}`);
+        }
+        const data = (await res.json()) as any;
+
+        const latestVersion = data['dist-tags']?.latest;
+        if (!latestVersion) throw new Error('No latest version found');
+
+        const versionData = data.versions[latestVersion];
+        const lastPublish = data.time[latestVersion];
+
+        // 2. Download Stats
+        // Use exact range 'last-week'
+        const dlRes = await fetch(`https://api.npmjs.org/downloads/point/last-week/${packageName}`);
+        let downloads = 0;
+        if (dlRes.ok) {
+            const dlData = (await dlRes.json()) as any;
+            downloads = dlData.downloads || 0;
+        }
+
+        // 3. Analysis
+        const lastDate = new Date(lastPublish);
+        const now = new Date();
+        const ageCodeDays = (now.getTime() - lastDate.getTime()) / (1000 * 3600 * 24);
+
+        let healthScore = 'MODERATE';
+        let recommendation = 'Usable, but verify.';
+        let riskFactors: string[] = [];
+
+        if (data.deprecated) {
+            healthScore = 'CRITICAL';
+            recommendation = 'DO NOT USE. Package is deprecated.';
+            riskFactors.push(`Deprecated: ${data.deprecated}`);
+        }
+
+        if (ageCodeDays > 730) { // 2 years
+            healthScore = 'STAGNANT';
+            recommendation = 'Consider alternatives. No updates in 2+ years.';
+            riskFactors.push('Mainteinance mode? (Old)');
+        }
+
+        if (downloads < 50) {
+            healthScore = 'LOW_ADOPTION';
+            riskFactors.push('Very low downloads (<50/week)');
+            if (healthScore !== 'CRITICAL') recommendation = 'High risk. Barely used.';
+        } else if (downloads > 100000 && ageCodeDays < 180) {
+            healthScore = 'EXCELLENT';
+            recommendation = 'Strongly recommended. Industry standard.';
+        } else if (downloads > 5000 && ageCodeDays < 365) {
+            healthScore = 'HEALTHY';
+            recommendation = 'Safe to use.';
+        }
+
+        return {
+            packageName,
+            latestVersion,
+            lastPublished: lastPublish,
+            downloadsLastWeek: downloads,
+            license: versionData.license || 'Unknown',
+            description: data.description,
+            healthScore,
+            recommendation,
+            riskFactors,
+            maintainers: data.maintainers?.length || 0
+        };
+
+    } catch (e: any) {
+        return {
+            status: 'ERROR',
+            message: `Analysis failed: ${e.message}`
+        };
+    }
+}