@rigstate/mcp 0.4.2 → 0.4.3

package/src/tools/complete-roadmap-task.ts

@@ -1,4 +1,29 @@
+
 import { SupabaseClient } from '@supabase/supabase-js';
+import { IntegrityGateResponse, ReleaseManifest } from '../lib/types.js';
+import { registry } from '../lib/tool-registry.js';
+import { CompleteRoadmapTaskInputSchema } from '../lib/schemas.js';
+
+// ============================================
+// Tool Registration
+// ============================================
+
+registry.register({
+    name: 'complete_roadmap_task',
+    description: `Finalizes a roadmap task. Generates a Release Manifest and triggers the Sovereign Harvesting protocol.`,
+    schema: CompleteRoadmapTaskInputSchema,
+    handler: async (args, context) => {
+        const result = await completeRoadmapTask(
+            context.supabase,
+            args.projectId,
+            args.summary,
+            args.taskId,
+            args.gitDiff,
+            args.integrityGate
+        );
+        return { content: [{ type: 'text', text: result.message }] };
+    }
+});
 
 export interface CompleteRoadmapTaskResponse {
     success: boolean;
@@ -11,7 +36,8 @@ export async function completeRoadmapTask(
     projectId: string,
     summary: string,
     taskId?: string,
-    gitDiff?: string
+    gitDiff?: string,
+    integrityGate?: IntegrityGateResponse
 ): Promise<CompleteRoadmapTaskResponse> {
 
     // 1. Identify the task
@@ -35,16 +61,36 @@ export async function completeRoadmapTask(
         }
     }
 
-    // 2. Update the Task Status
+    // 2. Generate Release Manifest if Integrity Gate info is present
+    let metadata: any = {};
+    if (integrityGate) {
+        const securityCheck = integrityGate.checks.find(c => (c as any).check === 'SECURITY');
+        const performanceCheck = integrityGate.checks.find(c => (c as any).check === 'PERFORMANCE');
+
+        const manifest: ReleaseManifest = {
+            executive_summary: summary,
+            security_certificate: {
+                status: securityCheck?.status === 'PASS' ? 'PASSED' : (securityCheck?.status === 'FAIL' ? 'FAILED' : 'WARNING'),
+                message: securityCheck?.message || 'No security audit performed.',
+                unsecured_tables: securityCheck?.details || []
+            },
+            performance_report: {
+                status: performanceCheck?.status === 'PASS' ? 'PASSED' : (performanceCheck?.status === 'FAIL' ? 'FAILED' : 'WARNING'),
+                message: performanceCheck?.message || 'No performance audit performed.',
+                issues_found: performanceCheck?.details ? (Array.isArray(performanceCheck.details) ? performanceCheck.details.length : 0) : 0
+            },
+            timestamp: new Date().toISOString()
+        };
+
+        metadata.release_manifest = manifest;
+    }
+
+    // 3. Update the Task Status
     const { error: updateError } = await supabase
         .from('roadmap_chunks')
         .update({
             status: 'COMPLETED',
-            completed_at: new Date().toISOString(),
-            // We could store the summary directly on the chunk if there's a column, 
-            // but mission_reports is the proper place for detailed logs.
-            // Let's check if we can update metadata or similar.
-            // For now, let's assume mission_reports is the way.
+            completed_at: new Date().toISOString()
         })
         .eq('id', targetTaskId);
 
@@ -52,26 +98,7 @@ export async function completeRoadmapTask(
         throw new Error(`Failed to update task status: ${updateError.message}`);
     }
 
-    // 3. Create a Mission Report entry
-    // Check if 'mission_reports' table exists and has the schema we expect.
-    // Based on previous code in index.ts (Frank Watcher):
-    /*
-        await supabase.from('mission_reports').insert({
-            bridge_id: task.id, // We might not have a bridge_id if this is direct from IDE
-            project_id: task.project_id,
-            task_id: task.task_id,
-            human_summary: humanSummary,
-            technical_summary: technicalSummary,
-            ...
-        });
-    */
-
-    // We'll insert a report. Since we don't have a bridge_id (this didn't come from the agent bridge queue),
-    // we'll leave it null if allowed, or we might need to create a dummy bridge entry?
-    // Let's assume bridge_id is nullable or we just skip it.
-    // If bridge_id is required, we might need to fake one or just log to a 'notes' field on roadmap_chunk if available.
-    // Let's try to insert into mission_reports first.
-
+    // 4. Create a Mission Report entry with the Manifest
     const { error: reportError } = await supabase
         .from('mission_reports')
         .insert({
@@ -79,18 +106,48 @@ export async function completeRoadmapTask(
             task_id: targetTaskId,
             human_summary: summary,
             technical_summary: gitDiff || 'Completed via IDE Direct Connection.',
-            // bridge_id: null // Assuming nullable
+            metadata: metadata
         });
 
     if (reportError) {
         console.warn('Failed to save mission report:', reportError.message);
-        // Fallback: Add a comment/note to the chunk?
-        // We'll just return a warning in the message.
+    }
+
+    // 5. SOVEREIGN HARVESTING: Trigger Reflection & Skill Extraction (Brynjar)
+    // Fire and forget - don't block completion on harvesting
+    try {
+        const apiKey = process.env.RIGSTATE_API_KEY;
+        // Default to localhost for development if not set
+        const apiUrl = process.env.RIGSTATE_API_URL || 'http://localhost:3000';
+
+        // In local dev, we might not have an API key set, so we allow it if it's localhost
+        const isLocal = apiUrl.includes('localhost') || apiUrl.includes('127.0.0.1');
+
+        if (apiKey || isLocal) {
+            fetch(`${apiUrl}/api/v1/skills/harvest`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(apiKey ? { 'Authorization': `Bearer ${apiKey}` } : {})
+                },
+                body: JSON.stringify({
+                    projectId,
+                    taskId: targetTaskId,
+                    summary,
+                    technicalSummary: gitDiff || 'Completed via IDE Direct Connection.',
+                    metadata: metadata
+                })
+            }).catch(e => console.error('Harvesting failed (silent):', e));
+        }
+    } catch (e) {
+        // Harvesting is non-critical, fail silently
     }
 
     return {
         success: true,
         taskId: targetTaskId!,
-        message: `Task completed successfully! Summary saved.`
+        message: integrityGate
+            ? `Task completed! 🎖️ Release Manifest generated and attached.`
+            : `Task completed successfully! Summary saved.`
     };
 }

package/src/tools/curator-tools.ts

@@ -0,0 +1,74 @@
+/**
+ * Phase 8.5: The Curator Protocol
+ * MCP Tools for Curator Operations
+ * 
+ * Sigrid's Tools for Global Knowledge Curation.
+ * These tools enable AI agents to contribute to and query the global antidote registry.
+ */
+
+import { registry } from '../lib/tool-registry.js';
+import {
+    queryGlobalAntidotes,
+    submitSignal,
+    getCuratorStats,
+    checkFortress,
+    QueryGlobalAntidotesSchema,
+    SubmitSignalSchema,
+    GetCuratorStatsSchema,
+    CheckFortressSchema
+} from '../lib/curator/index.js';
+
+// ============================================
+// Tool Registration
+// ============================================
+
+registry.register({
+    name: 'query_global_antidotes',
+    description: `Sigrid's Tool: Query the Global Antidotes Registry.
+Search for cross-platform intelligence signals (antidotes) that encode best practices.
+Use this to find relevant security, architecture, UX, and performance guidelines.`,
+    schema: QueryGlobalAntidotesSchema,
+    handler: async (args, context) => {
+        const result = await queryGlobalAntidotes(context.supabase, context.userId, args);
+        return { content: [{ type: 'text', text: result.formatted }] };
+    }
+});
+
+registry.register({
+    name: 'submit_curator_signal',
+    description: `Sigrid's Tool: Submit a new signal to the Curator Protocol.
+When you discover a best practice or anti-pattern during development, submit it as a signal.
+Signals are processed through a trust-scoring pipeline and may be promoted to global antidotes.
+Note: All submissions go through quarantine for human review.`,
+    schema: SubmitSignalSchema,
+    handler: async (args, context) => {
+        const result = await submitSignal(context.supabase, context.userId, args);
+        return { content: [{ type: 'text', text: result.message }] };
+    }
+});
+
+registry.register({
+    name: 'get_curator_stats',
+    description: `Get statistics about the Curator Registry.
+Shows total antidotes, fortress rules, pending quarantine, and today's curation activity.`,
+    schema: GetCuratorStatsSchema,
+    handler: async (args, context) => {
+        const result = await getCuratorStats(context.supabase, context.userId, args);
+        return { content: [{ type: 'text', text: result.formatted }] };
+    }
+});
+
+registry.register({
+    name: 'check_fortress_rules',
+    description: `Sigrid's Tool: Check an instruction against Fortress Rules.
+Before submitting a signal, use this to verify it doesn't conflict with immutable security rules.
+Fortress rules can NEVER be overridden by any signal.`,
+    schema: CheckFortressSchema,
+    handler: async (args, context) => {
+        const result = await checkFortress(context.supabase, context.userId, args);
+        return { content: [{ type: 'text', text: result.message }] };
+    }
+});
+
+// Export functions for historical compatibility if any tests use them directly
+export { queryGlobalAntidotes, submitSignal, getCuratorStats, checkFortress };

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

@@ -7,6 +7,28 @@
 
 import { SupabaseClient } from '@supabase/supabase-js';
 import type { DecisionsResponse, CouncilSession, RoadmapStep } from '../lib/types.js';
+import { registry } from '../lib/tool-registry.js';
+import { GetLatestDecisionsInputSchema } from '../lib/schemas.js';
+
+// ============================================
+// Tool Registration
+// ============================================
+
+registry.register({
+    name: 'get_latest_decisions',
+    description: `Fetches the most recent ADRs and decisions from The Council,
+including active roadmap steps and council session feedback.`,
+    schema: GetLatestDecisionsInputSchema,
+    handler: async (args, context) => {
+        const result = await getLatestDecisions(
+            context.supabase,
+            context.userId,
+            args.projectId,
+            args.limit
+        );
+        return { content: [{ type: 'text', text: result.summary }] };
+    }
+});
 
 export async function getLatestDecisions(
     supabase: SupabaseClient,

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

@@ -1,6 +1,27 @@
 
 import { SupabaseClient } from '@supabase/supabase-js';
 import type { RoadmapChunk } from '../lib/types.js';
+import { registry } from '../lib/tool-registry.js';
+import { GetNextRoadmapStepInputSchema } from '../lib/schemas.js';
+
+// ============================================
+// Tool Registration
+// ============================================
+
+registry.register({
+    name: 'get_next_roadmap_step',
+    description: `Fetches the next logical step from the roadmap for a project. 
+Useful for transitioning between tasks.`,
+    schema: GetNextRoadmapStepInputSchema,
+    handler: async (args, context) => {
+        const result = await getNextRoadmapStep(
+            context.supabase,
+            args.projectId,
+            args.currentStepId
+        );
+        return { content: [{ type: 'text', text: result.message }] };
+    }
+});
 
 export interface GetNextRoadmapStepResponse {
     nextStep: RoadmapChunk | null;

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

@@ -7,6 +7,23 @@
 
 import { SupabaseClient } from '@supabase/supabase-js';
 import type { ProjectContextResponse, TechStackInfo } from '../lib/types.js';
+import { injectGlobalContext } from '../lib/context-engine.js';
+import { registry } from '../lib/tool-registry.js';
+import { GetProjectContextInputSchema } from '../lib/schemas.js';
+
+// ============================================
+// Tool Registration
+// ============================================
+
+registry.register({
+    name: 'get_project_context',
+    description: `Returns the project type, tech stack, and high-level description for a Rigstate project.`,
+    schema: GetProjectContextInputSchema,
+    handler: async (args, context) => {
+        const result = await getProjectContext(context.supabase, context.userId, args.projectId);
+        return { content: [{ type: 'text', text: result.summary }] };
+    }
+});
 
 // Key libraries we care about for display
 const KEY_LIBS: Record<string, string> = {
@@ -148,7 +165,7 @@ export async function getProjectContext(
         });
     }
 
-    return {
+    const response: ProjectContextResponse = {
         project: {
             id: project.id,
             name: project.name,
@@ -160,4 +177,21 @@ export async function getProjectContext(
         techStack,
         summary: summaryParts.join('\n') || 'No project context available.'
     };
+
+    // Phase 8.5.5: Inject Global Context (Curator)
+    try {
+        const curatorContext = await injectGlobalContext(supabase, userId, {
+            frameworks: techStack.framework ? [techStack.framework] : [],
+            libraries: techStack.keyLibraries
+        });
+
+        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})`;
+    }
+
+    return response;
 }

package/src/tools/index.ts

@@ -15,3 +15,10 @@ export { submitIdea } from './submit-idea.js';
 export { updateRoadmap } from './update-roadmap.js';
 export { runArchitectureAudit } from './run-architecture-audit.js';
 
+// Curator Protocol (Phase 8.5 - Sigrid's Tools)
+export {
+    queryGlobalAntidotes,
+    submitSignal,
+    getCuratorStats,
+    checkFortress
+} from './curator-tools.js';

package/src/tools/list-features.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { ToolDefinition } from '../lib/tool-registry.js';
+import { ToolDefinition, registry } from '../lib/tool-registry.js';
 
 /**
  * Input Schema for List Features
@@ -65,3 +65,6 @@ Useful for understanding the strategic context and major milestones.`,
     }
 };
 
+registry.register(listFeaturesTool);
+
+

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

@@ -6,6 +6,27 @@
 
 import { SupabaseClient } from '@supabase/supabase-js';
 import type { ListRoadmapTasksResponse } from '../lib/types.js';
+import { registry } from '../lib/tool-registry.js';
+import { ListRoadmapTasksInputSchema } from '../lib/schemas.js';
+
+// ============================================
+// Tool Registration
+// ============================================
+
+registry.register({
+    name: 'list_roadmap_tasks',
+    description: `Lists all actionable tasks for a project that are not yet COMPLETED.
+Shows active and locked steps with their step numbers.`,
+    schema: ListRoadmapTasksInputSchema,
+    handler: async (args, context) => {
+        const result = await listRoadmapTasks(
+            context.supabase,
+            context.userId,
+            args.projectId
+        );
+        return { content: [{ type: 'text', text: result.formatted }] };
+    }
+});
 
 export async function listRoadmapTasks(
     supabase: SupabaseClient,

package/src/tools/planning-tools.ts

@@ -1,5 +1,45 @@
 import { SupabaseClient } from '@supabase/supabase-js';
 import { SaveToProjectBrainInput, UpdateRoadmapStatusInput, AddRoadmapChunkInput } from '../lib/types.js';
+import { registry } from '../lib/tool-registry.js';
+import {
+    SaveToProjectBrainInputSchema,
+    UpdateRoadmapStatusInputSchema,
+    AddRoadmapChunkInputSchema
+} from '../lib/schemas.js';
+
+// ============================================
+// Tool Registration
+// ============================================
+
+registry.register({
+    name: 'save_to_project_brain',
+    description: `Maja's Tool: Persists knowledge, decisions, and lessons learned to the Project Brain.`,
+    schema: SaveToProjectBrainInputSchema,
+    handler: async (args, context) => {
+        const result = await saveToProjectBrain(context.supabase, context.userId, args);
+        return { content: [{ type: 'text', text: result.message }] };
+    }
+});
+
+registry.register({
+    name: 'update_roadmap_status',
+    description: `Kine's Tool: Updates the status of a roadmap task and notifies Scribe system.`,
+    schema: UpdateRoadmapStatusInputSchema,
+    handler: async (args, context) => {
+        const result = await updateRoadmapStatus(context.supabase, context.userId, args);
+        return { content: [{ type: 'text', text: result.message }] };
+    }
+});
+
+registry.register({
+    name: 'add_roadmap_chunk',
+    description: `Kine's Tool: Adds a new task/chunk to the roadmap for feature decomposition.`,
+    schema: AddRoadmapChunkInputSchema,
+    handler: async (args, context) => {
+        const result = await addRoadmapChunk(context.supabase, context.userId, args);
+        return { content: [{ type: 'text', text: result.message }] };
+    }
+});
 
 /**
  * Maja's Tool: Save to Project Brain

package/src/tools/query-brain.ts

@@ -8,9 +8,33 @@
 
 import { SupabaseClient } from '@supabase/supabase-js';
 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.`,
+    schema: QueryBrainInputSchema,
+    handler: async (args, context) => {
+        const result = await queryBrain(
+            context.supabase,
+            context.userId,
+            args.projectId,
+            args.query,
+            args.limit,
+            args.threshold
+        );
+        return { content: [{ type: 'text', text: result.formatted }] };
+    }
+});
 
 // 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.

package/src/tools/run-architecture-audit.ts

@@ -7,6 +7,8 @@
 
 import { SupabaseClient } from '@supabase/supabase-js';
 import type { ArchitectureAuditResponse, AuditViolation } from '../lib/types.js';
+import { registry } from '../lib/tool-registry.js';
+import { RunArchitectureAuditInputSchema } from '../lib/schemas.js';
 
 // Vulnerability patterns for static analysis
 const VULNERABILITY_PATTERNS: {
@@ -80,6 +82,27 @@ function extractLineNumber(content: string, match: RegExpMatchArray): number {
     return (upToMatch.match(/\n/g) || []).length + 1;
 }
 
+// ============================================
+// Tool Registration
+// ============================================
+
+registry.register({
+    name: 'run_architecture_audit',
+    description: `Audits code against project memories and architecture rules.
+Returns violations or "Pass" status.`,
+    schema: RunArchitectureAuditInputSchema,
+    handler: async (args, context) => {
+        const result = await runArchitectureAudit(
+            context.supabase,
+            context.userId,
+            args.projectId,
+            args.filePath,
+            args.content
+        );
+        return { content: [{ type: 'text', text: result.summary }] };
+    }
+});
+
 export async function runArchitectureAudit(
     supabase: SupabaseClient,
     userId: string,

package/src/tools/save-decision.ts

@@ -7,6 +7,32 @@
 
 import { SupabaseClient } from '@supabase/supabase-js';
 import type { SaveDecisionResponse } from '../lib/types.js';
+import { registry } from '../lib/tool-registry.js';
+import { SaveDecisionInputSchema } from '../lib/schemas.js';
+
+// ============================================
+// Tool Registration
+// ============================================
+
+registry.register({
+    name: 'save_decision',
+    description: `Saves a new decision/ADR to the project's brain (project_memories).
+High-importance memory for architectural decisions.`,
+    schema: SaveDecisionInputSchema,
+    handler: async (args, context) => {
+        const result = await saveDecision(
+            context.supabase,
+            context.userId,
+            args.projectId,
+            args.title,
+            args.decision,
+            args.rationale,
+            args.category,
+            args.tags
+        );
+        return { content: [{ type: 'text', text: result.message }] };
+    }
+});
 
 export async function saveDecision(
     supabase: SupabaseClient,