@rigstate/mcp 0.4.2

package/src/tools/get-latest-decisions.ts

@@ -0,0 +1,130 @@
+/**
+ * Tool: get_latest_decisions
+ * 
+ * Fetches the most recent ADRs and decisions from The Council,
+ * including active roadmap steps and council session feedback.
+ */
+
+import { SupabaseClient } from '@supabase/supabase-js';
+import type { DecisionsResponse, CouncilSession, RoadmapStep } from '../lib/types.js';
+
+export async function getLatestDecisions(
+    supabase: SupabaseClient,
+    userId: string,
+    projectId: string,
+    limit: number = 5
+): Promise<DecisionsResponse> {
+    // 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');
+    }
+
+    // Fetch council sessions
+    const { data: sessionData, error: sessionError } = await supabase
+        .from('council_sessions')
+        .select('id, project_id, recruited_agents, feedback_summary, duration_ms, sprints_count, tasks_count, created_at')
+        .eq('project_id', projectId)
+        .order('created_at', { ascending: false })
+        .limit(limit);
+
+    const sessions: CouncilSession[] = (sessionData || []).map(s => ({
+        id: s.id,
+        projectId: s.project_id,
+        recruitedAgents: s.recruited_agents || [],
+        feedbackSummary: (s.feedback_summary || []).map((f: any) => ({
+            agentName: f.agentName || f.agent?.name || 'Unknown',
+            emoji: f.emoji || f.agent?.emoji || '🤖',
+            critiques: f.critiques || [],
+            approved: f.approved ?? true
+        })),
+        durationMs: s.duration_ms,
+        sprintsCount: s.sprints_count,
+        tasksCount: s.tasks_count,
+        createdAt: s.created_at
+    }));
+
+    // Fetch active roadmap step
+    const { data: activeStep, error: stepError } = await supabase
+        .from('roadmap_chunks')
+        .select('id, step_number, title, status, sprint_focus')
+        .eq('project_id', projectId)
+        .eq('status', 'ACTIVE')
+        .maybeSingle();
+
+    const activeRoadmapStep: RoadmapStep | null = activeStep
+        ? {
+            id: activeStep.id,
+            stepNumber: activeStep.step_number,
+            title: activeStep.title,
+            status: activeStep.status,
+            sprintFocus: activeStep.sprint_focus
+        }
+        : null;
+
+    // Build summary
+    const summaryParts: string[] = [];
+
+    // Add active step info
+    if (activeRoadmapStep) {
+        summaryParts.push(`=== CURRENT FOCUS ===`);
+        summaryParts.push(`Step ${activeRoadmapStep.stepNumber}: ${activeRoadmapStep.title}`);
+        if (activeRoadmapStep.sprintFocus) {
+            summaryParts.push(`Focus: ${activeRoadmapStep.sprintFocus}`);
+        }
+        summaryParts.push('');
+    }
+
+    // Add recent council decisions
+    if (sessions.length > 0) {
+        summaryParts.push(`=== RECENT COUNCIL SESSIONS (${sessions.length}) ===`);
+
+        for (const session of sessions) {
+            const date = new Date(session.createdAt).toLocaleDateString();
+            summaryParts.push(`\n📅 Session on ${date}`);
+            summaryParts.push(`   Agents: ${session.recruitedAgents.join(', ')}`);
+
+            if (session.feedbackSummary.length > 0) {
+                summaryParts.push(`   Key Feedback:`);
+                for (const feedback of session.feedbackSummary.slice(0, 3)) {
+                    const status = feedback.approved ? '✅' : '⚠️';
+                    summaryParts.push(`   ${feedback.emoji} ${feedback.agentName}: ${status}`);
+                    if (feedback.critiques.length > 0) {
+                        summaryParts.push(`      - ${feedback.critiques[0]}`);
+                    }
+                }
+            }
+        }
+    } else {
+        summaryParts.push(`No council sessions recorded yet.`);
+    }
+
+    // Fetch decision-type memories for additional context
+    const { data: decisionMemories } = await supabase
+        .from('project_memories')
+        .select('content, category, created_at')
+        .eq('project_id', projectId)
+        .eq('is_active', true)
+        .in('category', ['decision', 'architecture', 'constraint'])
+        .order('created_at', { ascending: false })
+        .limit(5);
+
+    if (decisionMemories && decisionMemories.length > 0) {
+        summaryParts.push(`\n=== KEY DECISIONS FROM BRAIN ===`);
+        for (const memory of decisionMemories) {
+            summaryParts.push(`- [${memory.category.toUpperCase()}] ${memory.content}`);
+        }
+    }
+
+    return {
+        sessions,
+        activeRoadmapStep,
+        summary: summaryParts.join('\n')
+    };
+}

package/src/tools/get-next-roadmap-step.ts

@@ -0,0 +1,76 @@
+
+import { SupabaseClient } from '@supabase/supabase-js';
+import type { RoadmapChunk } from '../lib/types.js';
+
+export interface GetNextRoadmapStepResponse {
+    nextStep: RoadmapChunk | null;
+    message: string;
+}
+
+export async function getNextRoadmapStep(
+    supabase: SupabaseClient,
+    projectId: string,
+    currentStepId?: string
+): Promise<GetNextRoadmapStepResponse> {
+
+    // Strategy:
+    // 1. If currentStepId is provided, look for the step with the next higher step_number.
+    // 2. If not, look for the first 'ACTIVE' step.
+    // 3. If no ACTIVE, look for the first 'LOCKED' step.
+
+    let currentStepNumber = 0;
+
+    if (currentStepId) {
+        const { data: current } = await supabase
+            .from('roadmap_chunks')
+            .select('step_number')
+            .eq('id', currentStepId)
+            .single();
+
+        if (current) {
+            currentStepNumber = current.step_number;
+        }
+    } else {
+        // Try to find currently active step to establish baseline
+        const { data: active } = await supabase
+            .from('roadmap_chunks')
+            .select('step_number')
+            .eq('project_id', projectId)
+            .eq('status', 'ACTIVE')
+            .order('step_number', { ascending: true })
+            .limit(1)
+            .single();
+
+        if (active) {
+            currentStepNumber = active.step_number;
+        }
+    }
+
+    // Find the next step > currentStepNumber
+    // We prioritize LOCKED or PENDING steps that come *after* the current one.
+    const { data: nextStep, error } = await supabase
+        .from('roadmap_chunks')
+        .select('*')
+        .eq('project_id', projectId)
+        .gt('step_number', currentStepNumber)
+        .neq('status', 'COMPLETED') // We want the next *workable* step
+        .order('step_number', { ascending: true })
+        .limit(1)
+        .single();
+
+    if (error && error.code !== 'PGRST116') { // PGRST116 is "Row not found" which is fine
+        throw new Error(`Failed to fetch next roadmap step: ${error.message}`);
+    }
+
+    if (!nextStep) {
+        return {
+            nextStep: null,
+            message: "No further steps found in the roadmap. You might be done! 🎉"
+        };
+    }
+
+    return {
+        nextStep: nextStep as RoadmapChunk,
+        message: `Next step found: [Step ${nextStep.step_number}] ${nextStep.title}`
+    };
+}

package/src/tools/get-project-context.ts

@@ -0,0 +1,163 @@
+/**
+ * Tool: get_project_context
+ * 
+ * Returns the project type, tech stack, and high-level description.
+ * This gives AI editors context about what they're working with.
+ */
+
+import { SupabaseClient } from '@supabase/supabase-js';
+import type { ProjectContextResponse, TechStackInfo } from '../lib/types.js';
+
+// Key libraries we care about for display
+const KEY_LIBS: Record<string, string> = {
+    'next': 'Next.js',
+    'react': 'React',
+    'vue': 'Vue',
+    'svelte': 'Svelte',
+    'angular': 'Angular',
+    'tailwindcss': 'Tailwind',
+    'prisma': 'Prisma',
+    'drizzle-orm': 'Drizzle',
+    '@supabase/supabase-js': 'Supabase',
+    'stripe': 'Stripe',
+    'openai': 'OpenAI',
+    'typescript': 'TypeScript',
+    'framer-motion': 'Framer Motion',
+    'zod': 'Zod',
+    'ai': 'Vercel AI',
+};
+
+export async function getProjectContext(
+    supabase: SupabaseClient,
+    userId: string,
+    projectId: string
+): Promise<ProjectContextResponse> {
+    // Fetch project with ownership check
+    const { data: project, error: projectError } = await supabase
+        .from('projects')
+        .select('id, name, description, project_type, created_at, last_indexed_at, detected_stack, repository_tree')
+        .eq('id', projectId)
+        .eq('owner_id', userId)
+        .single();
+
+    if (projectError || !project) {
+        throw new Error('Project not found or access denied');
+    }
+
+    // Fetch Digest Data
+    const { data: agentTasks } = await supabase
+        .from('agent_bridge')
+        .select('id, roadmap_chunks(title), execution_summary, completed_at')
+        .eq('project_id', projectId)
+        .eq('status', 'COMPLETED')
+        .order('completed_at', { ascending: false })
+        .limit(3);
+
+    const { data: roadmapItems } = await supabase
+        .from('roadmap_chunks')
+        .select('title, status, updated_at')
+        .eq('project_id', projectId)
+        .order('updated_at', { ascending: false })
+        .limit(3);
+
+    // Parse tech stack from detected_stack
+    const techStack: TechStackInfo = {
+        framework: null,
+        orm: null,
+        database: null,
+        keyLibraries: [],
+        topFolders: []
+    };
+
+    if (project.detected_stack) {
+        const stack = project.detected_stack as {
+            dependencies?: Record<string, string>;
+            devDependencies?: Record<string, string>;
+        };
+        const allDeps = { ...stack.dependencies, ...stack.devDependencies };
+
+        for (const [name, version] of Object.entries(allDeps)) {
+            const cleanVersion = (version as string).replace(/[\^~]/g, '');
+
+            // Categorize
+            if (name === 'next' || name === 'react' || name === 'vue' || name === 'angular' || name === 'svelte') {
+                if (!techStack.framework) {
+                    techStack.framework = `${KEY_LIBS[name] || name} ${cleanVersion}`;
+                }
+            } else if (name.includes('prisma') || name.includes('drizzle') || name.includes('typeorm')) {
+                if (!techStack.orm) {
+                    techStack.orm = `${KEY_LIBS[name] || name} ${cleanVersion}`;
+                }
+            } else if (KEY_LIBS[name]) {
+                techStack.keyLibraries.push(`${KEY_LIBS[name]} ${cleanVersion}`);
+            }
+        }
+    }
+
+    // Extract top folders from repository tree
+    if (project.repository_tree && Array.isArray(project.repository_tree)) {
+        techStack.topFolders = [...new Set(
+            project.repository_tree
+                .filter((t: any) => t.type === 'tree' && !t.path.includes('/'))
+                .map((t: any) => t.path)
+        )].slice(0, 10) as string[];
+    }
+
+    // Build summary
+    const summaryParts: string[] = [];
+
+    if (project.project_type) {
+        summaryParts.push(`Project Type: ${project.project_type.toUpperCase()}`);
+    }
+
+    if (techStack.framework) {
+        summaryParts.push(`Framework: ${techStack.framework}`);
+    }
+
+    if (techStack.orm) {
+        summaryParts.push(`ORM: ${techStack.orm}`);
+    }
+
+    if (techStack.keyLibraries.length > 0) {
+        summaryParts.push(`Key Libraries: ${techStack.keyLibraries.join(', ')}`);
+    }
+
+    if (techStack.topFolders.length > 0) {
+        summaryParts.push(`Top Folders: ${techStack.topFolders.join(', ')}`);
+    }
+
+    if (project.description) {
+        summaryParts.push(`\nDescription: ${project.description}`);
+    }
+
+    // Add Digest to Summary
+    summaryParts.push('\n=== RECENT ACTIVITY DIGEST ===');
+
+    if (agentTasks && agentTasks.length > 0) {
+        summaryParts.push('\nLatest AI Executions:');
+        agentTasks.forEach((t: any) => {
+            const time = t.completed_at ? new Date(t.completed_at).toLocaleString() : 'Recently';
+            summaryParts.push(`- [${time}] ${t.roadmap_chunks?.title || 'Task'}: ${t.execution_summary || 'Completed'}`);
+        });
+    }
+
+    if (roadmapItems && roadmapItems.length > 0) {
+        summaryParts.push('\nRoadmap Updates:');
+        roadmapItems.forEach((i: any) => {
+            summaryParts.push(`- ${i.title} is now ${i.status}`);
+        });
+    }
+
+    return {
+        project: {
+            id: project.id,
+            name: project.name,
+            description: project.description,
+            projectType: project.project_type,
+            createdAt: project.created_at,
+            lastIndexedAt: project.last_indexed_at
+        },
+        techStack,
+        summary: summaryParts.join('\n') || 'No project context available.'
+    };
+}

package/src/tools/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Tools Index
+ * 
+ * Re-exports all MCP tools for easy importing.
+ */
+
+// Read operations
+export { getProjectContext } from './get-project-context.js';
+export { queryBrain } from './query-brain.js';
+export { getLatestDecisions } from './get-latest-decisions.js';
+
+// Write operations
+export { saveDecision } from './save-decision.js';
+export { submitIdea } from './submit-idea.js';
+export { updateRoadmap } from './update-roadmap.js';
+export { runArchitectureAudit } from './run-architecture-audit.js';
+

package/src/tools/list-features.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { ToolDefinition } from '../lib/tool-registry.js';
+
+/**
+ * Input Schema for List Features
+ */
+const InputSchema = z.object({
+    projectId: z.string().uuid().describe('The UUID of the Rigstate project')
+});
+
+/**
+ * Tool Definition: list_features
+ */
+export const listFeaturesTool: ToolDefinition<typeof InputSchema> = {
+    name: 'list_features',
+    description: `Lists all high-level features (epics) for a project.
+Useful for understanding the strategic context and major milestones.`,
+    schema: InputSchema,
+    handler: async ({ projectId }, { supabase, userId }) => {
+        // 1. 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');
+        }
+
+        // 2. Fetch features
+        const { data: features, error } = await supabase
+            .from('features')
+            .select('id, name, description, priority, status')
+            .eq('project_id', projectId)
+            .neq('status', 'ARCHIVED')
+            .order('created_at', { ascending: false }); // Sort by newest (or priority if column existed properly typed)
+
+        // Note: 'horizon' was not in my simple schema mental model, removed to be safe or use 'status' as proxy.
+        // Assuming strict schema adherence.
+        // If priority column is text, sorting by it strictly might be weird if not enum. 
+        // Let's trust 'created_at' for stability for now.
+
+        if (error) {
+            throw new Error(`Failed to fetch features: ${error.message}`);
+        }
+
+        // 3. Format response
+        const formatted = (features || []).length > 0
+            ? (features || []).map(f => {
+                const priorityStr = f.priority === 'MVP' ? '[MVP] ' : '';
+                return `- ${priorityStr}${f.name} (${f.status})`;
+            }).join('\n')
+            : 'No active features found.';
+
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: formatted
+                }
+            ]
+        };
+    }
+};
+

package/src/tools/list-roadmap-tasks.ts

@@ -0,0 +1,61 @@
+/**
+ * Tool: list_roadmap_tasks
+ * 
+ * Lists all roadmap tasks for a project that are not completed.
+ */
+
+import { SupabaseClient } from '@supabase/supabase-js';
+import type { ListRoadmapTasksResponse } from '../lib/types.js';
+
+export async function listRoadmapTasks(
+    supabase: SupabaseClient,
+    userId: string,
+    projectId: string
+): Promise<ListRoadmapTasksResponse> {
+    // 1. 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');
+    }
+
+    // 2. Fetch non-completed tasks
+    const { data: tasks, error } = await supabase
+        .from('roadmap_chunks')
+        .select('id, title, priority, status, step_number, prompt_content')
+        .eq('project_id', projectId)
+        .neq('status', 'COMPLETED')
+        .order('priority', { ascending: false })
+        .order('step_number', { ascending: true });
+
+    if (error) {
+        console.error('Failed to fetch roadmap tasks:', error);
+        throw new Error('Failed to fetch roadmap tasks');
+    }
+
+    // 3. Format response
+    const formatted = (tasks || []).length > 0
+        ? (tasks || []).map(t => {
+            const statusEmoji = t.status === 'ACTIVE' ? '🔵' : '🔒';
+            const priorityStr = t.priority ? `[${t.priority}]` : '';
+            return `${statusEmoji} Step ${t.step_number}: ${t.title} (ID: ${t.id})`;
+        }).join('\n')
+        : 'No active or locked tasks found in the roadmap.';
+
+    return {
+        tasks: (tasks || []).map(t => ({
+            id: t.id,
+            title: t.title,
+            priority: t.priority,
+            status: t.status,
+            step_number: t.step_number,
+            prompt_content: t.prompt_content
+        })),
+        formatted
+    };
+}