@rigstate/mcp 0.7.7 → 0.7.8

package/dist/index.js

@@ -2052,26 +2052,38 @@ var KEY_LIBS = {
   "ai": "Vercel AI"
 };
 async function getProjectContext(supabase, userId, projectId) {
-  const { data: rawData, error: projectError } = await supabase.rpc("get_project_context_secure", {
-    p_project_id: projectId,
-    p_user_id: userId
-  }).single();
-  const projectRow = rawData;
-  if (projectError || !projectRow) {
-    console.error("Project fetch failed:", projectError);
-    throw new Error("Project not found or access denied");
+  let projectRow = null;
+  let projectError = null;
+  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;
+  }
+  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})`);
+    }
   }
-  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
-  };
+  const project = projectRow;
   const stackDef = projectRow.architectural_dna?.stack_definition;
   const { data: allChunks } = await supabase.rpc("get_roadmap_chunks_secure", {
     p_project_id: projectId,
@@ -2099,13 +2111,9 @@ async function getProjectContext(supabase, userId, projectId) {
     for (const [name, version] of Object.entries(allDeps)) {
       const cleanVersion = version.replace(/[\^~]/g, "");
       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}`);
       }
@@ -2144,13 +2152,10 @@ async function getProjectContext(supabase, userId, projectId) {
       frameworks: techStack.framework ? [techStack.framework] : [],
       libraries: techStack.keyLibraries
     });
-    if (curatorContext) {
-      response.summary += `
+    if (curatorContext) response.summary += `
 
 === CURATOR INTELLIGENCE ===${curatorContext}`;
-    }
   } catch (e) {
-    console.error("Failed to inject global context:", e);
     response.summary += `
 
 (Curator Context Unavailable: ${e.message})`;
@@ -2162,99 +2167,60 @@ async function getProjectContext(supabase, userId, projectId) {
 init_esm_shims();
 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 }] };
   }
 });
-async function generateQueryEmbedding(query) {
-  const apiKey = process.env.RIGSTATE_API_KEY;
-  const apiUrl = process.env.RIGSTATE_API_URL || "http://localhost:3000/api/v1";
-  if (!apiKey) {
-    return null;
-  }
+async function queryBrain(supabase, userId, projectId, query, limit = 8) {
+  let memories = [];
+  let searchType = "SECURE-GATEWAY";
   try {
-    const response = await fetch(`${apiUrl}/intelligence/embed`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({ text: query })
+    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 (!response.ok) {
-      const errorText = await response.text();
-      console.error(`Embedding API error (${response.status}):`, errorText);
-      return null;
+    if (!error && data) {
+      memories = data.map((m) => ({
+        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) {
+    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) => ({
+        id: m.id,
+        content: m.content,
+        category: m.category,
+        tags: m.tags,
+        netVotes: m.importance,
+        createdAt: m.created_at
+      }));
     }
-    const result = await response.json();
-    return result.data?.embedding || null;
-  } catch (error) {
-    console.error("Failed to generate embedding via Proxy:", error);
-    return null;
-  }
-}
-async function queryBrain(supabase, userId, projectId, query, limit = 8, threshold = 0.5) {
-  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");
-  }
-  const embedding = await generateQueryEmbedding(query);
-  let memories = [];
-  const { data: searchResults, error: searchError } = 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) => ({
-      id: m.id,
-      content: m.content,
-      category: m.category,
-      tags: m.tags,
-      netVotes: m.importance,
-      createdAt: m.created_at
-    }));
   }
   let relevantFeatures = [];
   try {
-    const { data: projectRow } = await supabase.rpc("get_project_context_secure", {
-      p_project_id: projectId,
-      p_user_id: userId
-    }).single();
+    const { data: projectRow } = await supabase.from("projects").select("functional_spec").eq("id", projectId).single();
     if (projectRow?.functional_spec) {
-      const spec = typeof projectRow.functional_spec === "string" ? JSON.parse(projectRow.functional_spec) : projectRow.functional_spec;
+      const spec = projectRow.functional_spec;
       const features = spec.featureList || spec.features || [];
       relevantFeatures = features.filter((f) => (f.name || f.title)?.toLowerCase().includes(query.toLowerCase())).slice(0, 3);
     }
   } catch (e) {
-    console.warn("Feature fetch failed in brain query", e);
   }
-  const contextLines = memories.map((m) => {
-    const voteIndicator = m.netVotes && m.netVotes < 0 ? ` [\u26A0\uFE0F 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)";
+  const contextLines = memories.map((m) => `- [${(m.category || "GENERAL").toUpperCase()}]: ${m.content}`);
   let formatted = `=== PROJECT BRAIN: RELEVANT MEMORIES ===
 Search Mode: ${searchType}
 Query: "${query}"`;
@@ -2268,20 +2234,12 @@ Query: "${query}"`;
 
 Found ${memories.length} relevant memories:
 
-${contextLines.join("\n")}
-
-==========================================`;
+${contextLines.join("\n")}`;
   if (memories.length === 0 && relevantFeatures.length === 0) {
     formatted = `=== PROJECT BRAIN ===
-Query: "${query}"
-No relevant memories or features found.
-=======================`;
+No relevant info found for "${query}".`;
   }
-  return {
-    query,
-    memories,
-    formatted
-  };
+  return { query, memories, formatted };
 }
 
 // src/tools/get-latest-decisions.ts
@@ -2826,24 +2784,27 @@ var listFeaturesTool = {
 Useful for understanding the strategic context and major milestones.`,
   schema: InputSchema,
   handler: async ({ projectId }, { supabase, userId }) => {
-    const { data: projectRow, error: projectError } = 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");
+    let projectRow = null;
+    let dbFeatures = [];
+    let source = "DB";
+    try {
+      const { data } = await supabase.rpc("get_project_context_secure", { p_project_id: projectId, p_user_id: userId }).single();
+      projectRow = data;
+    } catch (e) {
+      const { data } = await supabase.from("projects").select("id, functional_spec").eq("id", projectId).single();
+      projectRow = data;
+    }
+    if (!projectRow) throw new Error(`Project ${projectId} not found or access denied.`);
+    try {
+      const { data } = await supabase.rpc("get_project_features_secure", { p_project_id: projectId, p_user_id: userId });
+      dbFeatures = data || [];
+    } catch (e) {
+      const { data } = await supabase.from("project_features").select("id, name, description, status").eq("project_id", projectId);
+      dbFeatures = data || [];
     }
-    const { data: dbFeatures, error: dbError } = await supabase.rpc("get_project_features_secure", {
-      p_project_id: projectId,
-      p_user_id: userId
-    });
     let featuresList = [];
-    let source = "DB";
-    if (!dbError && dbFeatures && dbFeatures.length > 0) {
-      featuresList = dbFeatures.map((f) => ({
-        ...f,
-        title: f.name
-      }));
+    if (dbFeatures && dbFeatures.length > 0) {
+      featuresList = dbFeatures.map((f) => ({ ...f, title: f.name }));
     } else {
       source = "FALLBACK_SPEC";
       const spec = projectRow.functional_spec;
@@ -2858,15 +2819,11 @@ Useful for understanding the strategic context and major milestones.`,
       }
     }
     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}) ===
-` + featuresList.map((f) => {
-      return `- ${f.title} [${f.status}]`;
-    }).join("\n");
-    return {
-      content: [{ type: "text", text: formatted }]
-    };
+` + featuresList.map((f) => `- ${f.title} [${f.status}]`).join("\n");
+    return { content: [{ type: "text", text: formatted }] };
   }
 };
 registry.register(listFeaturesTool);
@@ -3813,15 +3770,43 @@ async function saveToProjectBrain(supabase, userId, input) {
   const fullContent = `# ${title}
 
 ${content}`;
-  const { data: memoryId, error } = await supabase.rpc("save_project_memory_secure", {
-    p_project_id: projectId,
-    p_user_id: userId,
-    p_content: fullContent,
-    p_category: category.toLowerCase(),
-    p_tags: tags || [],
-    p_importance: category === "DECISION" || category === "ARCHITECTURE" ? 9 : 5
-  });
-  if (error) throw new Error(`Failed to save memory: ${error.message}`);
+  let memoryId = null;
+  let saveError = null;
+  try {
+    const { data, error } = await supabase.rpc("save_project_memory_secure", {
+      p_project_id: projectId,
+      p_user_id: userId,
+      p_content: fullContent,
+      p_category: category.toLowerCase(),
+      p_tags: tags || [],
+      p_importance: category === "DECISION" || category === "ARCHITECTURE" ? 9 : 5
+    });
+    if (data && !error) {
+      memoryId = data;
+    } else {
+      saveError = error;
+    }
+  } catch (e) {
+    saveError = e;
+  }
+  if (!memoryId) {
+    console.warn("RPC save_project_memory_secure failed, trying direct insert. Error:", 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.id;
+    } else {
+      console.error("Direct insert failed:", error);
+      throw new Error(`Failed to save memory: ${error?.message || "Unknown error"}`);
+    }
+  }
   return {
     success: true,
     memoryId,