@rigstate/mcp 0.7.6 → 0.7.8

package/dist/index.js

@@ -1903,10 +1903,10 @@ var CompleteRoadmapTaskInputSchema = z4.object({
 
 // src/lib/project-context-utils.ts
 init_esm_shims();
-async function buildProjectSummary(project, techStack, activeTask, nextTask, agentTasks, roadmapItems, stackDef, supabase) {
+async function buildProjectSummary(project, techStack, activeTask, nextTask, agentTasks, roadmapItems, stackDef, supabase, userId) {
   const summaryParts = [];
   summaryParts.push(`Project Type: ${project.project_type?.toUpperCase() || "UNKNOWN"}`);
-  if (stackDef) {
+  if (stackDef || activeTask || nextTask) {
     summaryParts.push("\n=== ACTIVE MISSION PARAMETERS ===");
     if (activeTask) {
       summaryParts.push(`\u26A0\uFE0F  CURRENT OBJECTIVE: T-${activeTask.step_number}: ${activeTask.title}`);
@@ -1937,11 +1937,19 @@ async function buildProjectSummary(project, techStack, activeTask, nextTask, age
         summaryParts.push(`   Tags: ${activeTask.tags.join(", ")}`);
       }
       if (activeTask.feature_id) {
-        const { data: feature } = await supabase.from("project_features").select("name, description").eq("id", activeTask.feature_id).single();
-        if (feature) {
-          summaryParts.push(`
+        try {
+          const { data: dbFeatures } = await supabase.rpc("get_project_features_secure", {
+            p_project_id: project.id,
+            p_user_id: userId
+          });
+          const feature = dbFeatures?.find((f) => f.id === activeTask.feature_id);
+          if (feature) {
+            summaryParts.push(`
    Parent Feature: ${feature.name}`);
-          summaryParts.push(`   Feature Vision: ${feature.description}`);
+            summaryParts.push(`   Feature Vision: ${feature.description}`);
+          }
+        } catch (e) {
+          console.warn("Feature context fetch failed", e);
         }
       }
       summaryParts.push("\n   ACTION: Focus ALL coding efforts on completing this task.");
@@ -1964,13 +1972,15 @@ async function buildProjectSummary(project, techStack, activeTask, nextTask, age
       summaryParts.push(`2. PROACTIVE: Instead of asking "How can I help?", ask "Shall we start on T-${nextTask.step_number}?"`);
     }
     summaryParts.push("\n=== CURRENT STACK ===");
-    if (stackDef.frontend) summaryParts.push(`Frontend: ${stackDef.frontend.framework} (${stackDef.frontend.language})`);
-    if (stackDef.backend) summaryParts.push(`Backend: ${stackDef.backend.service} (${stackDef.backend.database})`);
-    if (stackDef.styling) summaryParts.push(`Styling: ${stackDef.styling.framework} ${stackDef.styling.library || ""}`);
-    if (stackDef.hosting) summaryParts.push(`Infrastructure: ${stackDef.hosting.provider}`);
-  } else {
-    if (techStack.framework) summaryParts.push(`Framework: ${techStack.framework}`);
-    if (techStack.orm) summaryParts.push(`ORM: ${techStack.orm}`);
+    if (stackDef) {
+      if (stackDef.frontend) summaryParts.push(`Frontend: ${stackDef.frontend.framework} (${stackDef.frontend.language})`);
+      if (stackDef.backend) summaryParts.push(`Backend: ${stackDef.backend.service} (${stackDef.backend.database})`);
+      if (stackDef.styling) summaryParts.push(`Styling: ${stackDef.styling.framework} ${stackDef.styling.library || ""}`);
+      if (stackDef.hosting) summaryParts.push(`Infrastructure: ${stackDef.hosting.provider}`);
+    } else {
+      if (techStack.framework) summaryParts.push(`Framework: ${techStack.framework}`);
+      if (techStack.orm) summaryParts.push(`ORM: ${techStack.orm}`);
+    }
   }
   if (project.description) {
     summaryParts.push(`
@@ -1984,8 +1994,8 @@ Description: ${project.description}`);
     if (spec.coreProblem) summaryParts.push(`Core Problem: ${spec.coreProblem}`);
     if (spec.featureList && Array.isArray(spec.featureList)) {
       summaryParts.push("\nKey Features & Nuances:");
-      spec.featureList.filter((f) => f.priority === "MVP").forEach((f) => {
-        summaryParts.push(`- ${f.name}: ${f.description}`);
+      spec.featureList.filter((f) => f.priority === "MVP" || f.priority === "HIGH").slice(0, 10).forEach((f) => {
+        summaryParts.push(`- ${f.name}: ${f.description?.substring(0, 200)}`);
       });
     }
   }
@@ -2002,7 +2012,7 @@ Description: ${project.description}`);
     summaryParts.push("\nLatest AI Executions:");
     agentTasks.forEach((t) => {
       const time = t.completed_at ? new Date(t.completed_at).toLocaleString() : "Recently";
-      summaryParts.push(`- [${time}] ${t.roadmap_title || "Task"}: ${t.execution_summary || "Completed"}`);
+      summaryParts.push(`- [${time}] ${t.roadmap_title || "Task"}: ${t.execution_summary?.substring(0, 100) || "Completed"}`);
     });
   }
   if (roadmapItems && roadmapItems.length > 0) {
@@ -2042,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,
@@ -2089,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}`);
       }
@@ -2114,7 +2132,8 @@ async function getProjectContext(supabase, userId, projectId) {
     agentTasks || [],
     roadmapItems || [],
     stackDef,
-    supabase
+    supabase,
+    userId
   );
   const response = {
     project: {
@@ -2133,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})`;
@@ -2151,102 +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");
     }
-    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("hybrid_search_memories", {
-    p_project_id: projectId,
-    p_query: query,
-    p_embedding: embedding || null,
-    p_limit: limit,
-    p_similarity_threshold: threshold || 0.1
-  });
-  if (searchError) {
-    const { data: recentMemories } = await supabase.from("project_memories").select("id, content, category, tags, importance, created_at").eq("project_id", projectId).eq("is_active", true).order("created_at", { ascending: false }).limit(limit);
-    if (recentMemories) {
-      memories = recentMemories.map((m) => ({
+  } 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 || "general",
-        tags: m.tags || [],
-        netVotes: m.importance || 0,
+        category: m.category,
+        tags: m.tags,
+        netVotes: m.importance,
         createdAt: m.created_at
       }));
     }
-  } else if (searchResults) {
-    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: features } = await supabase.from("project_features").select("name, status, description").eq("project_id", projectId).or(`name.ilike.%${query}%,description.ilike.%${query}%`).limit(3);
-    if (features) relevantFeatures = features;
+    const { data: projectRow } = await supabase.from("projects").select("functional_spec").eq("id", projectId).single();
+    if (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)" : "HYBRID (FTS + Fuzzy)";
+  const contextLines = memories.map((m) => `- [${(m.category || "GENERAL").toUpperCase()}]: ${m.content}`);
   let formatted = `=== PROJECT BRAIN: RELEVANT MEMORIES ===
 Search Mode: ${searchType}
 Query: "${query}"`;
@@ -2254,26 +2228,18 @@ Query: "${query}"`;
     formatted += `
 
 === RELATED FEATURES ===
-` + relevantFeatures.map((f) => `- ${f.name} [${f.status}]`).join("\n");
+` + relevantFeatures.map((f) => `- ${f.name || f.title} [${f.status || "Active"}]`).join("\n");
   }
   formatted += `
 
 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
@@ -2818,32 +2784,33 @@ var listFeaturesTool = {
 Useful for understanding the strategic context and major milestones.`,
   schema: InputSchema,
   handler: async ({ projectId }, { supabase, userId }) => {
-    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");
+    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;
     }
-    const { data: project, error: projectError } = await supabase.from("projects").select("id, functional_spec").eq("id", projectId).single();
-    if (projectError || !project) {
-      throw new Error("Project details not found");
+    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.from("project_features").select("id, name, description, status").eq("project_id", projectId).neq("status", "shadow").order("created_at", { ascending: false });
     let featuresList = [];
-    let source = "DB";
-    if (!dbError && dbFeatures && dbFeatures.length > 0) {
-      featuresList = dbFeatures.map((f) => ({
-        ...f,
-        title: f.name
-        // Map back to title specifically for uniform handling below
-      }));
+    if (dbFeatures && dbFeatures.length > 0) {
+      featuresList = dbFeatures.map((f) => ({ ...f, title: f.name }));
     } else {
       source = "FALLBACK_SPEC";
-      console.error(`[WARN] Project ${projectId}: 'project_features' empty or missing. Falling back to 'functional_spec'.`);
-      const spec = project.functional_spec;
-      if (spec && typeof spec === "object" && Array.isArray(spec.features)) {
-        featuresList = spec.features.map((f) => ({
+      const spec = projectRow.functional_spec;
+      const features = spec?.featureList || spec?.features;
+      if (Array.isArray(features)) {
+        featuresList = features.map((f) => ({
           id: "legacy",
           title: f.name || f.title,
           description: f.description,
@@ -2852,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);
@@ -3807,19 +3770,46 @@ async function saveToProjectBrain(supabase, userId, input) {
   const fullContent = `# ${title}
 
 ${content}`;
-  const { data, error } = await supabase.from("project_memories").insert({
-    project_id: projectId,
-    content: fullContent,
-    category: category.toLowerCase(),
-    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}`);
+  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: data.id,
+    memoryId,
     message: `\u2705 Saved [${category}] "${title}" to Project Brain.`
   };
 }