@rigstate/mcp 0.7.5 → 0.7.7

package/package.json

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

package/src/lib/arch-analysis.ts

@@ -0,0 +1,171 @@
+import { GitCommit, DiscoveredFeature } from './types.js';
+
+/**
+ * Parse git log output into structured commits
+ */
+export function parseGitLog(logOutput: string): GitCommit[] {
+    const commits: GitCommit[] = [];
+    const entries = logOutput.split('\n---COMMIT---\n').filter(Boolean);
+
+    for (const entry of entries) {
+        const lines = entry.trim().split('\n');
+        if (lines.length >= 3) {
+            commits.push({
+                hash: lines[0]?.replace('hash:', '').trim() || '',
+                date: lines[1]?.replace('date:', '').trim() || '',
+                author: lines[2]?.replace('author:', '').trim() || '',
+                message: lines.slice(3).join('\n').trim()
+            });
+        }
+    }
+
+    return commits;
+}
+
+/**
+ * Analyze commits to identify major milestones
+ */
+export function identifyMilestones(commits: GitCommit[]): { date: string; summary: string; commits: string[] }[] {
+    const milestones: { date: string; summary: string; commits: string[] }[] = [];
+
+    // Keywords that indicate significant features
+    const featurePatterns = [
+        { pattern: /\b(auth|authentication|login|signup|oauth)\b/i, category: 'Authentication System' },
+        { pattern: /\b(database|schema|migration|supabase|postgres)\b/i, category: 'Database Setup' },
+        { pattern: /\b(api|endpoint|route)\b/i, category: 'API Development' },
+        { pattern: /\b(ui|component|layout|design|tailwind)\b/i, category: 'UI/Component Development' },
+        { pattern: /\b(test|spec|jest|vitest)\b/i, category: 'Testing Infrastructure' },
+        { pattern: /\b(deploy|ci|cd|github|vercel|docker)\b/i, category: 'DevOps & Deployment' },
+        { pattern: /\b(feature|implement|add|create|build)\b/i, category: 'Feature Implementation' },
+        { pattern: /\b(fix|bug|patch|resolve)\b/i, category: 'Bug Fixes & Patches' },
+        { pattern: /\b(refactor|clean|optimize|improve)\b/i, category: 'Code Quality Improvements' },
+        { pattern: /\b(docs|readme|documentation)\b/i, category: 'Documentation' },
+        { pattern: /\b(config|setup|init|scaffold)\b/i, category: 'Project Configuration' },
+        { pattern: /\b(agent|mcp|ai|llm|openai)\b/i, category: 'AI/Agent Integration' },
+        { pattern: /\b(roadmap|milestone|chunk)\b/i, category: 'Roadmap System' },
+        { pattern: /\b(report|pdf|manifest|governance)\b/i, category: 'Reporting & Governance' },
+    ];
+
+    // Group commits by category
+    const categoryMap = new Map<string, { commits: GitCommit[]; latestDate: string }>();
+
+    for (const commit of commits) {
+        for (const { pattern, category } of featurePatterns) {
+            if (pattern.test(commit.message)) {
+                if (!categoryMap.has(category)) {
+                    categoryMap.set(category, { commits: [], latestDate: commit.date });
+                }
+                const entry = categoryMap.get(category)!;
+                entry.commits.push(commit);
+                if (new Date(commit.date) > new Date(entry.latestDate)) {
+                    entry.latestDate = commit.date;
+                }
+                break; // Only categorize each commit once
+            }
+        }
+    }
+
+    // Convert to milestones (only include categories with 2+ commits)
+    for (const [category, data] of categoryMap.entries()) {
+        if (data.commits.length >= 2) {
+            milestones.push({
+                date: data.latestDate,
+                summary: `${category} (${data.commits.length} commits)`,
+                commits: data.commits.slice(0, 5).map(c => c.message.split('\n')[0].substring(0, 80))
+            });
+        }
+    }
+
+    // Sort by date descending
+    milestones.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+
+    return milestones;
+}
+
+/**
+ * Map directory structure to potential features
+ */
+export function analyzeFilesystem(tree: string[]): { featureDirectories: string[]; configFiles: string[] } {
+    const featurePatterns = [
+        /^(apps|packages)\/[^/]+\/src\/(components|features|modules)\/[^/]+$/,
+        /^(apps|packages)\/[^/]+\/src\/app\/[^/]+$/,
+        /^src\/(components|features|modules|pages)\/[^/]+$/,
+        /^(apps|packages)\/[^/]+$/,
+    ];
+
+    const configPatterns = [
+        /package\.json$/,
+        /tsconfig.*\.json$/,
+        /\.env.*$/,
+        /next\.config\./,
+        /tailwind\.config\./,
+        /supabase.*\.toml$/,
+    ];
+
+    const featureDirectories = tree.filter(path =>
+        featurePatterns.some(pattern => pattern.test(path))
+    );
+
+    const configFiles = tree.filter(path =>
+        configPatterns.some(pattern => pattern.test(path))
+    );
+
+    return {
+        featureDirectories: [...new Set(featureDirectories)].slice(0, 20),
+        configFiles: [...new Set(configFiles)].slice(0, 10)
+    };
+}
+
+/**
+ * Generate discovered features from milestones and filesystem
+ */
+export function generateDiscoveredFeatures(
+    milestones: { date: string; summary: string; commits: string[] }[],
+    filesystemAnalysis: { featureDirectories: string[]; configFiles: string[] }
+): DiscoveredFeature[] {
+    const features: DiscoveredFeature[] = [];
+    let priority = 1;
+
+    // From Git milestones
+    for (const milestone of milestones.slice(0, 10)) {
+        const id = `ghost-${Date.now()}-${priority}`;
+        features.push({
+            id,
+            title: milestone.summary.split('(')[0].trim(),
+            description: `Reconstructed from ${milestone.commits.length} commits. Last activity: ${new Date(milestone.date).toLocaleDateString()}`,
+            status: 'COMPLETED',
+            source: 'git',
+            evidence: milestone.commits,
+            estimatedCompletionDate: milestone.date,
+            priority: priority++
+        });
+    }
+
+    // From filesystem (major directories as features)
+    const directoryFeatures = filesystemAnalysis.featureDirectories
+        .filter(dir => dir.includes('src/') || dir.startsWith('apps/') || dir.startsWith('packages/'))
+        .slice(0, 5);
+
+    for (const dir of directoryFeatures) {
+        const name = dir.split('/').pop() || dir;
+        const id = `ghost-fs-${Date.now()}-${priority}`;
+
+        // Skip if we already have a similar feature from git
+        if (features.some(f => f.title.toLowerCase().includes(name.toLowerCase()))) {
+            continue;
+        }
+
+        features.push({
+            id,
+            title: `${name.charAt(0).toUpperCase() + name.slice(1)} Module`,
+            description: `Detected from directory structure: ${dir}`,
+            status: 'COMPLETED',
+            source: 'filesystem',
+            evidence: [dir],
+            estimatedCompletionDate: new Date().toISOString(),
+            priority: priority++
+        });
+    }
+
+    return features;
+}

package/src/lib/curator/actions/submit.ts

@@ -11,15 +11,14 @@ export async function submitSignal(
     userId: string,
     input: z.infer<typeof SubmitSignalSchema>
 ) {
-    // 1. Verify project ownership
-    const { data: project, error: projectError } = await supabase
-        .from('projects')
-        .select('id')
-        .eq('id', input.projectId)
-        .eq('owner_id', userId)
-        .single();
-
-    if (projectError || !project) {
+    // 1. Verify project access
+    const { data: hasAccess, error: accessError } = await supabase
+        .rpc('check_project_access_secure', {
+            p_project_id: input.projectId,
+            p_user_id: userId
+        });
+
+    if (accessError || !hasAccess) {
         throw new Error('Project not found or access denied');
     }
 

package/src/lib/project-context-utils.ts

@@ -0,0 +1,148 @@
+import { TechStackInfo } from '../lib/types.js';
+
+export async function buildProjectSummary(
+    project: any,
+    techStack: TechStackInfo,
+    activeTask: any,
+    nextTask: any,
+    agentTasks: any[],
+    roadmapItems: any[],
+    stackDef: any,
+    supabase: any,
+    userId: string
+): Promise<string> {
+    const summaryParts: string[] = [];
+
+    summaryParts.push(`Project Type: ${project.project_type?.toUpperCase() || 'UNKNOWN'}`);
+
+    // Active Mission Parameters
+    if (stackDef || activeTask || nextTask) {
+        summaryParts.push('\n=== ACTIVE MISSION PARAMETERS ===');
+        if (activeTask) {
+            summaryParts.push(`⚠️  CURRENT OBJECTIVE: T-${activeTask.step_number}: ${activeTask.title}`);
+            summaryParts.push(`   Role: ${activeTask.role || 'Developer'}`);
+
+            const detailedInstructions = activeTask.prompt_content || activeTask.instruction_set;
+            if (detailedInstructions) {
+                summaryParts.push(`   Instructions: ${detailedInstructions.substring(0, 1000)}...`);
+            }
+            if (activeTask.architectural_brief) {
+                summaryParts.push(`\n   Architectural Brief: ${activeTask.architectural_brief}`);
+            }
+            if (activeTask.context_summary) {
+                summaryParts.push(`\n   Context: ${activeTask.context_summary}`);
+            }
+            if (activeTask.checklist && activeTask.checklist.length > 0) {
+                summaryParts.push('\n   Checklist (DoD):');
+                activeTask.checklist.forEach((item: any) => {
+                    summaryParts.push(`     [ ] ${typeof item === 'string' ? item : item.task}`);
+                });
+            }
+            if (activeTask.metadata && Object.keys(activeTask.metadata).length > 0) {
+                summaryParts.push(`\n   Technical Metadata: ${JSON.stringify(activeTask.metadata)}`);
+            }
+            if (activeTask.tags && activeTask.tags.length > 0) {
+                summaryParts.push(`   Tags: ${activeTask.tags.join(', ')}`);
+            }
+
+            // Enhanced Feature Context (Secure)
+            if (activeTask.feature_id) {
+                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: any) => f.id === activeTask.feature_id);
+
+                    if (feature) {
+                        summaryParts.push(`\n   Parent Feature: ${feature.name}`);
+                        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.');
+        } else if (nextTask) {
+            summaryParts.push(`⏸  SYSTEM IDLE (Waiting for command)`);
+            summaryParts.push(`   Suggested Next Mission: T-${nextTask.step_number}: ${nextTask.title}`);
+            if (nextTask.tags && nextTask.tags.length > 0) {
+                summaryParts.push(`   Scope: ${nextTask.tags.join(', ')}`);
+            }
+            summaryParts.push(`   ACTION: Ask the user "Shall we start T-${nextTask.step_number}?"`);
+        } else {
+            summaryParts.push('✅  ALL MISSIONS COMPLETE. Awaiting new roadmap items.');
+        }
+
+        summaryParts.push('\n=== AI BEHAVIORAL INSTRUCTIONS ===');
+        if (activeTask) {
+            summaryParts.push(`1. FOCUS: The user is working on T-${activeTask.step_number}. Help them complete it.`);
+            summaryParts.push(`2. COMPLIANCE: Ensure all code follows project standards.`);
+        } else if (nextTask) {
+            summaryParts.push(`1. NUDGE: No active task found. Suggest starting T-${nextTask.step_number} (${nextTask.title}).`);
+            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) {
+            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(`\nDescription: ${project.description}`);
+    }
+
+    if (project.functional_spec) {
+        summaryParts.push('\n=== STRATEGIC PROJECT SPECIFICATION (NUANCES) ===');
+        const spec = typeof project.functional_spec === 'string' ? JSON.parse(project.functional_spec) : project.functional_spec;
+
+        if (spec.projectDescription) summaryParts.push(`Vision: ${spec.projectDescription}`);
+        if (spec.targetAudience) summaryParts.push(`Audience: ${spec.targetAudience}`);
+        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: any) => f.priority === 'MVP' || f.priority === 'HIGH').slice(0, 10).forEach((f: any) => {
+                summaryParts.push(`- ${f.name}: ${f.description?.substring(0, 200)}`);
+            });
+        }
+    }
+
+    summaryParts.push('\n=== RIGSTATE TOOLING GUIDELINES ===');
+    summaryParts.push('You have access to specialized MCP tools. USE THEM TO SUCCEED:');
+    summaryParts.push('1. NEVER guess about architecture. Use `query_brain` to search project documentation.');
+    summaryParts.push('2. BEFORE coding, check `get_learned_instructions` to see if you have been corrected before.');
+    summaryParts.push('3. When finishing a task, ALWAYS update the roadmap using `update_roadmap`.');
+    summaryParts.push('4. If you discover a reusable pattern, submit it with `submit_curator_signal`.');
+    summaryParts.push('5. For large refactors, use `run_architecture_audit` to check against rules.');
+    summaryParts.push('6. Store major decisions using `save_decision` (ADR).');
+
+    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_title || 'Task'}: ${t.execution_summary?.substring(0, 100) || 'Completed'}`);
+        });
+    }
+
+    if (roadmapItems && roadmapItems.length > 0) {
+        summaryParts.push('\nRoadmap Updates:');
+        roadmapItems.forEach((i: any) => {
+            summaryParts.push(`- ${i.title} is now ${i.status}`);
+        });
+    }
+
+    return summaryParts.join('\n') || 'No project context available.';
+}

package/src/lib/types-roadmap.ts

@@ -0,0 +1,43 @@
+export interface RoadmapChunk {
+    id: string;
+    project_id: string;
+    feature_id: string | null;
+    title: string;
+    description: string | null;
+    status: string;
+    priority: string | null;
+    step_number: number;
+    prompt_content: string | null;
+    architectural_brief?: string | null;
+    context_summary?: string | null;
+    checklist?: any[] | null;
+    metadata?: any | null;
+    tags?: string[] | null;
+    created_at: string;
+    completed_at: string | null;
+}
+
+export interface ListRoadmapTasksResponse {
+    tasks: Array<{
+        id: string;
+        title: string;
+        priority: string | null;
+        status: string;
+        step_number: number;
+        prompt_content: string | null;
+        architectural_brief?: string | null;
+        context_summary?: string | null;
+        metadata?: any | null;
+        checklist?: any[] | null;
+        tags?: string[] | null;
+    }>;
+    formatted: string;
+}
+
+export interface RoadmapStep {
+    id: string;
+    stepNumber: number;
+    title: string;
+    status: string;
+    sprintFocus: string | null;
+}

package/src/lib/types.ts

@@ -176,31 +176,7 @@ export interface SecurityIntegrityResponse {
 // ROADMAP & TASK TYPES
 // =============================================================================
 
-export interface RoadmapChunk {
-    id: string;
-    project_id: string;
-    feature_id: string | null;
-    title: string;
-    description: string | null;
-    status: string;
-    priority: string | null;
-    step_number: number;
-    prompt_content: string | null;
-    created_at: string;
-    completed_at: string | null;
-}
-
-export interface ListRoadmapTasksResponse {
-    tasks: Array<{
-        id: string;
-        title: string;
-        priority: string | null;
-        status: string;
-        step_number: number;
-        prompt_content: string | null;
-    }>;
-    formatted: string;
-}
+export * from './types-roadmap.js';
 
 // =============================================================================
 // AGENT BRIDGE & RULES TYPES
@@ -254,3 +230,43 @@ export interface ReleaseManifest {
     };
     timestamp: string;
 }
+
+
+// =============================================================================
+// ARCHAEOLOGICAL SCAN TYPES
+// =============================================================================
+
+export interface GitCommit {
+    hash: string;
+    message: string;
+    date: string;
+    author: string;
+}
+
+export interface DiscoveredFeature {
+    id: string;
+    title: string;
+    description: string;
+    status: 'COMPLETED';
+    source: 'git' | 'filesystem' | 'combined';
+    evidence: string[];
+    estimatedCompletionDate: string;
+    priority: number;
+}
+
+export interface ArchaeologicalReport {
+    projectId: string;
+    scanDate: string;
+    gitAnalysis: {
+        totalCommits: number;
+        analyzedCommits: number;
+        milestones: { date: string; summary: string; commits: string[] }[];
+    };
+    filesystemAnalysis: {
+        totalDirectories: number;
+        featureDirectories: string[];
+        configFiles: string[];
+    };
+    discoveredFeatures: DiscoveredFeature[];
+    recommendations: string[];
+}

package/src/server/types.ts

@@ -13,7 +13,7 @@ export interface McpServerConfig {
 }
 
 export const SERVER_NAME = 'rigstate-mcp';
-export const SERVER_VERSION = '0.5.0'; // Evolutionary Update
+export const SERVER_VERSION = '0.7.5';
 
 export interface AuthContext {
     supabase: SupabaseClient;

package/src/tools/analyze-database-performance.ts

@@ -26,8 +26,20 @@ interface TableMetadata {
 
 export async function analyzeDatabasePerformance(
     supabase: SupabaseClient,
+    userId: string,
     input: AnalyzeDatabasePerformanceInput
 ): Promise<{ issues: PerformanceIssue[], summary: string }> {
+    // 0. Verify project access
+    const { data: hasAccess, error: accessError } = await supabase
+        .rpc('check_project_access_secure', {
+            p_project_id: input.projectId,
+            p_user_id: userId
+        });
+
+    if (accessError || !hasAccess) {
+        throw new Error('Project not found or access denied');
+    }
+
     const issues: PerformanceIssue[] = [];
 
     // 1. Fetch Database Metadata