@rigstate/mcp 0.7.7 → 0.7.9

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rigstate/mcp",
-    "version": "0.7.7",
+    "version": "0.7.9",
     "description": "Rigstate MCP Server - Model Context Protocol for AI Editors",
     "type": "module",
     "main": "./dist/index.js",

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

@@ -50,52 +50,54 @@ export async function getProjectContext(
     userId: string,
     projectId: string
 ): Promise<ProjectContextResponse> {
-    // Define RPC response type
-    interface ProjectContextRow {
-        id: string;
-        name: string;
-        description: string;
-        project_type: string;
-        created_at: string;
-        last_indexed_at: string;
-        detected_stack: any;
-        repository_tree: any;
-        architectural_dna: any;
-        functional_spec: any;
-    }
-
-    // Fetch project securely via RPC (bypasses RLS with strict checks)
-    const { data: rawData, error: projectError } = await supabase
-        .rpc('get_project_context_secure', {
-            p_project_id: projectId,
-            p_user_id: userId
-        })
-        .single();
+    // 1. Try secure RPC first
+    let projectRow: any = null;
+    let projectError: any = null;
 
-    const projectRow = rawData as ProjectContextRow;
-
-    if (projectError || !projectRow) {
-        console.error('Project fetch failed:', projectError);
-        throw new Error('Project not found or access denied');
+    try {
+        const { data, error } = await supabase
+            .rpc('get_project_context_secure', {
+                p_project_id: projectId,
+                p_user_id: userId
+            })
+            .single();
+
+        if (data && !error) {
+            projectRow = data;
+        } else {
+            projectError = error;
+        }
+    } catch (e) {
+        projectError = e;
     }
 
-    // Map RPC result to tool structure
-    const project = {
-        id: projectRow.id,
-        name: projectRow.name,
-        description: projectRow.description,
-        project_type: projectRow.project_type,
-        created_at: projectRow.created_at,
-        last_indexed_at: projectRow.last_indexed_at,
-        detected_stack: projectRow.detected_stack,
-        repository_tree: projectRow.repository_tree,
-        functional_spec: projectRow.functional_spec
-    };
+    // 2. Fallback to direct table query if RPC failed (Policies were updated to allow members)
+    if (!projectRow) {
+        console.error(`RPC get_project_context_secure failed for ${projectId}, falling back to direct query. Error:`, projectError);
+        const { data, error } = await supabase
+            .from('projects')
+            .select(`
+                id, name, description, project_type, created_at, last_indexed_at, detected_stack, repository_tree, functional_spec,
+                architectural_dna(stack_definition)
+            `)
+            .eq('id', projectId)
+            .single();
+
+        if (data) {
+            projectRow = {
+                ...data,
+                architectural_dna: Array.isArray(data.architectural_dna) ? data.architectural_dna[0] : data.architectural_dna
+            };
+        } else {
+            console.error('Project fetch failed completely:', error);
+            throw new Error(`Project ${projectId} not found or access denied. (User: ${userId})`);
+        }
+    }
 
-    // DNA is now directly available
-    const stackDef = (projectRow.architectural_dna as any)?.stack_definition;
+    const project = projectRow;
+    const stackDef = projectRow.architectural_dna?.stack_definition;
 
-    // Continuity Loop: Fetch Active & Next Tasks via secure RPC
+    // 3. Continuity Loop: Fetch Active & Next Tasks
     const { data: allChunks } = await supabase
         .rpc('get_roadmap_chunks_secure', {
             p_project_id: projectId,
@@ -103,14 +105,12 @@ export async function getProjectContext(
         });
 
     const tasks = (allChunks || []) as any[];
-
-    // In-memory filtering to match original logic
     const activeTask = tasks.find(t => ['IN_PROGRESS', 'ACTIVE'].includes(t.status));
     const nextTask = tasks
         .filter(t => ['PENDING', 'LOCKED'].includes(t.status))
         .sort((a, b) => a.step_number - b.step_number)[0];
 
-    // Fetch Digest Data via secure RPC
+    // 4. Fetch Digest Data
     const { data: agentTasks } = await supabase
         .rpc('get_agent_bridge_secure', {
             p_project_id: projectId,
@@ -122,7 +122,7 @@ export async function getProjectContext(
         .sort((a, b) => new Date(b.updated_at || b.created_at).getTime() - new Date(a.updated_at || a.created_at).getTime())
         .slice(0, 2);
 
-    // Parse tech stack from detected_stack
+    // 5. Build tech stack info
     const techStack: TechStackInfo = {
         framework: null,
         orm: null,
@@ -132,31 +132,21 @@ export async function getProjectContext(
     };
 
     if (project.detected_stack) {
-        const stack = project.detected_stack as {
-            dependencies?: Record<string, string>;
-            devDependencies?: Record<string, string>;
-        };
+        const stack = project.detected_stack as any;
         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}`;
-                }
+                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}`;
-                }
+                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
@@ -190,18 +180,14 @@ export async function getProjectContext(
         summary
     };
 
-    // Phase 8.5.5: Inject Global Context (Curator)
+    // Inject Global Context
     try {
         const curatorContext = await injectGlobalContext(supabase, userId, {
             frameworks: techStack.framework ? [techStack.framework] : [],
             libraries: techStack.keyLibraries
         });
-
-        if (curatorContext) {
-            response.summary += `\n\n=== CURATOR INTELLIGENCE ===${curatorContext}`;
-        }
+        if (curatorContext) response.summary += `\n\n=== CURATOR INTELLIGENCE ===${curatorContext}`;
     } catch (e: any) {
-        console.error('Failed to inject global context:', e);
         response.summary += `\n\n(Curator Context Unavailable: ${e.message})`;
     }
 

package/src/tools/list-features.ts

@@ -17,39 +17,46 @@ export const listFeaturesTool: ToolDefinition<typeof InputSchema> = {
 Useful for understanding the strategic context and major milestones.`,
     schema: InputSchema,
     handler: async ({ projectId }, { supabase, userId }) => {
-        // 1. Verify project access and fetch context
-        const { data: projectRow, error: projectError } = await supabase
-            .rpc('get_project_context_secure', {
-                p_project_id: projectId,
-                p_user_id: userId
-            })
-            .single() as any;
+        // 1. Fetch project and features
+        let projectRow: any = null;
+        let dbFeatures: any[] = [];
+        let source = 'DB';
+
+        try {
+            // 1. Try secure gateway for project context
+            const { data, error } = await supabase
+                .rpc('get_project_context_secure', { p_project_id: projectId, p_user_id: userId })
+                .single();
 
-        if (projectError || !projectRow) {
-            throw new Error('Project details not found or access denied');
+            if (error || !data) throw error || new Error('Project not found');
+            projectRow = data;
+        } catch (e) {
+            console.error('[list_features] Secure Project RPC failed:', e);
+            // Fallback: Direct table query (Requires proper RLS)
+            const { data } = await supabase.from('projects').select('id, functional_spec').eq('id', projectId).single();
+            projectRow = data;
         }
 
-        // 2. Primary Strategy: Fetch from 'project_features' via secure RPC
-        const { data: dbFeatures, error: dbError } = await supabase
-            .rpc('get_project_features_secure', {
-                p_project_id: projectId,
-                p_user_id: userId
-            });
+        if (!projectRow) throw new Error(`Project ${projectId} not found or access denied.`);
 
-        let featuresList: any[] = [];
-        let source = 'DB';
+        try {
+            // Try secure gateway for features
+            const { data } = await supabase.rpc('get_project_features_secure', { p_project_id: projectId, p_user_id: userId });
+            dbFeatures = data || [];
+        } catch (e) {
+            // Fallback to direct table
+            const { data } = await supabase.from('project_features').select('id, name, description, status').eq('project_id', projectId);
+            dbFeatures = data || [];
+        }
 
-        if (!dbError && dbFeatures && dbFeatures.length > 0) {
-            featuresList = dbFeatures.map((f: any) => ({
-                ...f,
-                title: f.name
-            }));
+        let featuresList: any[] = [];
+        if (dbFeatures && dbFeatures.length > 0) {
+            featuresList = dbFeatures.map((f: any) => ({ ...f, title: f.name }));
         } else {
-            // 3. Fallback Strategy: Extract from 'functional_spec'
+            // Fallback to spec
             source = 'FALLBACK_SPEC';
             const spec = projectRow.functional_spec as any;
             const features = spec?.featureList || spec?.features;
-
             if (Array.isArray(features)) {
                 featuresList = features.map((f: any) => ({
                     id: 'legacy',
@@ -60,19 +67,14 @@ Useful for understanding the strategic context and major milestones.`,
             }
         }
 
-        // 4. Format Response
         if (featuresList.length === 0) {
-            return { content: [{ type: 'text', text: 'No active features found (checked DB and Spec).' }] };
+            return { content: [{ type: 'text', text: 'No active features found.' }] };
         }
 
         const formatted = `=== PROJECT FEATURES (Source: ${source}) ===\n` +
-            featuresList.map(f => {
-                return `- ${f.title} [${f.status}]`;
-            }).join('\n');
+            featuresList.map(f => `- ${f.title} [${f.status}]`).join('\n');
 
-        return {
-            content: [{ type: 'text', text: formatted }]
-        };
+        return { content: [{ type: 'text', text: formatted }] };
     }
 };
 

package/src/tools/planning-tools.ts

@@ -60,8 +60,12 @@ export async function saveToProjectBrain(
 
     const fullContent = `# ${title}\n\n${content}`;
 
-    const { data: memoryId, error } = await supabase
-        .rpc('save_project_memory_secure', {
+    let memoryId: string | null = null;
+    let saveError: any = null;
+
+    try {
+        // 1. Try secure RPC
+        const { data, error } = await supabase.rpc('save_project_memory_secure', {
             p_project_id: projectId,
             p_user_id: userId,
             p_content: fullContent,
@@ -70,7 +74,42 @@ export async function saveToProjectBrain(
             p_importance: (category === 'DECISION' || category === 'ARCHITECTURE') ? 9 : 5
         });
 
-    if (error) throw new Error(`Failed to save memory: ${error.message}`);
+        if (error) {
+            console.error('[save_to_project_brain] RPC Error:', error);
+            saveError = error;
+        } else if (data) {
+            memoryId = data;
+        }
+    } catch (e) {
+        console.error('[save_to_project_brain] RPC Exception:', e);
+        saveError = e;
+    }
+
+    // 2. Fallback to direct insert (Requires proper RLS)
+    if (!memoryId) {
+        console.warn('[save_to_project_brain] Falling back to direct insert. RPC Error/Response was:', saveError);
+        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 (data) {
+            memoryId = (data as any).id;
+        } else {
+            console.error('[save_to_project_brain] Direct insert failed:', error);
+            const detail = error?.message || (saveError as any)?.message || 'Unknown error';
+            throw new Error(`Failed to save memory: ${detail}. (Note: secure RPC failed first)`);
+        }
+    }
 
     return {
         success: true,

package/src/tools/query-brain.ts

@@ -2,8 +2,7 @@
  * 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.
+ * against the project's memories (RAG).
  */
 
 import { SupabaseClient } from '@supabase/supabase-js';
@@ -11,116 +10,76 @@ import type { BrainQueryResponse, MemoryRecord } from '../lib/types.js';
 import { registry } from '../lib/tool-registry.js';
 import { QueryBrainInputSchema } from '../lib/schemas.js';
 
-// ============================================
-// Tool Registration
-// ============================================
-
 registry.register({
     name: 'query_brain',
-    description: `Takes a natural language query and performs semantic search
-against the project's memories (RAG), returning relevant
-architecture rules, decisions, and constraints.`,
+    description: `Takes a natural language query and performs semantic search against the project's memories (RAG).`,
     schema: QueryBrainInputSchema,
     handler: async (args, context) => {
-        const result = await queryBrain(
-            context.supabase,
-            context.userId,
-            args.projectId,
-            args.query,
-            args.limit,
-            args.threshold
-        );
+        const result = await queryBrain(context.supabase, context.userId, args.projectId, args.query, args.limit);
         return { content: [{ type: 'text', text: result.formatted }] };
     }
 });
 
-// Generate embedding using the Rigstate Intelligence API (Proxy)
-async function generateQueryEmbedding(query: string): Promise<number[] | null> {
-    const apiKey = process.env.RIGSTATE_API_KEY;
-    const apiUrl = process.env.RIGSTATE_API_URL || 'http://localhost:3000/api/v1';
-
-    if (!apiKey) {
-        return null;
-    }
-
-    try {
-        const response = await fetch(`${apiUrl}/intelligence/embed`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${apiKey}`
-            },
-            body: JSON.stringify({ text: query })
-        });
-
-        if (!response.ok) {
-            const errorText = await response.text();
-            console.error(`Embedding API error (${response.status}):`, errorText);
-            return null;
-        }
-
-        const result = await response.json() as any;
-        return result.data?.embedding || null;
-    } catch (error) {
-        console.error('Failed to generate embedding via Proxy:', error);
-        return null;
-    }
-}
-
 export async function queryBrain(
     supabase: SupabaseClient,
     userId: string,
     projectId: string,
     query: string,
-    limit: number = 8,
-    threshold: number = 0.5
+    limit: number = 8
 ): Promise<BrainQueryResponse> {
-    // First, verify project access
-    const { data: hasAccess, error: accessError } = await supabase
-        .rpc('check_project_access_secure', {
-            p_project_id: projectId,
-            p_user_id: userId
-        });
-
-    if (accessError || !hasAccess) {
-        throw new Error('Project not found or access denied');
-    }
-
-    // Try semantic search first using the match_memories RPC
-    const embedding = await generateQueryEmbedding(query);
     let memories: MemoryRecord[] = [];
+    let searchType = 'SECURE-GATEWAY';
 
-    // Use the secure search RPC
-    const { data: searchResults, error: searchError } = await supabase
-        .rpc('query_project_brain_secure', {
+    try {
+        // Try secure search RPC
+        const { data, error } = await supabase.rpc('query_project_brain_secure', {
             p_project_id: projectId,
             p_user_id: userId,
             p_query: query,
             p_limit: limit
         });
 
-    if (searchError || !searchResults) {
-        console.error('Brain query failed:', searchError);
-        memories = [];
-    } else {
-        memories = searchResults.map((m: any) => ({
-            id: m.id,
-            content: m.content,
-            category: m.category,
-            tags: m.tags,
-            netVotes: m.importance,
-            createdAt: m.created_at
-        }));
+        if (!error && data) {
+            memories = data.map((m: any) => ({
+                id: m.id,
+                content: m.content,
+                category: m.category,
+                tags: m.tags,
+                netVotes: m.importance,
+                createdAt: m.created_at
+            }));
+        } else {
+            throw error || new Error('No data');
+        }
+    } catch (e) {
+        // Fallback to direct table query (Policies allow members)
+        searchType = 'DIRECT-FALLBACK';
+        const { data } = await supabase
+            .from('project_memories')
+            .select('id, content, category, tags, importance, created_at')
+            .eq('project_id', projectId)
+            .eq('is_active', true)
+            .or(`content.ilike.%${query}%,category.ilike.%${query}%`)
+            .order('created_at', { ascending: false })
+            .limit(limit);
+
+        if (data) {
+            memories = data.map((m: any) => ({
+                id: m.id,
+                content: m.content,
+                category: m.category,
+                tags: m.tags,
+                netVotes: m.importance,
+                createdAt: m.created_at
+            }));
+        }
     }
 
-    // --- FETCH RELEVANT FEATURES FROM SPEC ---
+    // 3. Related Features from Spec (Use Secure Gateway)
     let relevantFeatures: any[] = [];
     try {
         const { data: projectRow } = await supabase
-            .rpc('get_project_context_secure', {
-                p_project_id: projectId,
-                p_user_id: userId
-            })
+            .rpc('get_project_context_secure', { p_project_id: projectId, p_user_id: userId })
             .single() as any;
 
         if (projectRow?.functional_spec) {
@@ -134,40 +93,19 @@ export async function queryBrain(
                 .slice(0, 3);
         }
     } catch (e) {
-        console.warn('Feature fetch failed in brain query', e);
+        console.error('[query_brain] Failed to fetch project spec for features:', e);
     }
 
-    // Format memories into a readable context block
-    const contextLines = memories.map((m: any) => {
-        const voteIndicator = m.netVotes && m.netVotes < 0 ? ` [⚠️ POORLY RATED: ${m.netVotes}]` : '';
-        const tagStr = m.tags && m.tags.length > 0 ? ` [${m.tags.join(', ')}]` : '';
-        const category = m.category ? m.category.toUpperCase() : 'GENERAL';
-        return `- [${category}]${tagStr}${voteIndicator}: ${m.content}`;
-    });
-
-    const searchType = embedding ? 'TRIPLE-HYBRID (Vector + FTS + Fuzzy)' : 'SECURE-GATEWAY (Fuzzy)';
-
-    let formatted = `=== PROJECT BRAIN: RELEVANT MEMORIES ===
-Search Mode: ${searchType}
-Query: "${query}"`;
-
+    const contextLines = memories.map((m: any) => `- [${(m.category || 'GENERAL').toUpperCase()}]: ${m.content}`);
+    let formatted = `=== PROJECT BRAIN: RELEVANT MEMORIES ===\nSearch Mode: ${searchType}\nQuery: "${query}"`;
     if (relevantFeatures.length > 0) {
-        formatted += `\n\n=== RELATED FEATURES ===\n` +
-            relevantFeatures.map((f: any) => `- ${f.name || f.title} [${f.status || 'Active'}]`).join('\n');
+        formatted += `\n\n=== RELATED FEATURES ===\n` + relevantFeatures.map((f: any) => `- ${f.name || f.title} [${f.status || 'Active'}]`).join('\n');
     }
-
-    formatted += `\n\nFound ${memories.length} relevant memories:\n\n${contextLines.join('\n')}\n\n==========================================`;
+    formatted += `\n\nFound ${memories.length} relevant memories:\n\n${contextLines.join('\n')}`;
 
     if (memories.length === 0 && relevantFeatures.length === 0) {
-        formatted = `=== PROJECT BRAIN ===
-Query: "${query}"
-No relevant memories or features found.
-=======================`;
+        formatted = `=== PROJECT BRAIN ===\nNo relevant info found for "${query}".`;
     }
 
-    return {
-        query,
-        memories,
-        formatted
-    };
+    return { query, memories, formatted };
 }