@rigstate/mcp 0.4.2

package/src/resources/project-morals.ts

@@ -0,0 +1,92 @@
+/**
+ * Rigstate MCP Server - Local Rules Resource
+ * 
+ * Reads local .rigstate/rules.md files and injects them as high-priority rules.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface LocalRule {
+    source: string;
+    content: string;
+    priority: 'high' | 'medium';
+}
+
+export interface ProjectMoralsResponse {
+    rules: LocalRule[];
+    formatted: string;
+}
+
+const LOCAL_RULE_FILES = [
+    '.rigstate/rules.md',
+    '.rigstate/morals.md',
+    '.rigstate/standards.md',
+    '.cursor/rules.md',
+    '.cursorrules'
+];
+
+/**
+ * Read local project morals/rules from filesystem
+ */
+export function getProjectMorals(workspacePath?: string): ProjectMoralsResponse {
+    const basePath = workspacePath || process.cwd();
+    const rules: LocalRule[] = [];
+
+    for (const ruleFile of LOCAL_RULE_FILES) {
+        const fullPath = path.join(basePath, ruleFile);
+
+        try {
+            if (fs.existsSync(fullPath)) {
+                const content = fs.readFileSync(fullPath, 'utf-8');
+
+                if (content.trim()) {
+                    rules.push({
+                        source: ruleFile,
+                        content: content.trim(),
+                        priority: ruleFile.includes('.rigstate') ? 'high' : 'medium'
+                    });
+                }
+            }
+        } catch (e) {
+            // File not readable, skip
+        }
+    }
+
+    // Format for context injection
+    let formatted = '';
+
+    if (rules.length > 0) {
+        formatted = `## LOCAL PROJECT MORALS (HIGH PRIORITY)\n`;
+        formatted += `These rules are defined in the local workspace and MUST be followed:\n\n`;
+
+        for (const rule of rules) {
+            formatted += `### Source: ${rule.source}\n`;
+            formatted += rule.content;
+            formatted += '\n\n';
+        }
+    } else {
+        formatted = `No local rules found. You can create .rigstate/rules.md to define project-specific guidelines.`;
+    }
+
+    return {
+        rules,
+        formatted
+    };
+}
+
+/**
+ * Check if local rules exist
+ */
+export function hasLocalRules(workspacePath?: string): boolean {
+    const basePath = workspacePath || process.cwd();
+
+    for (const ruleFile of LOCAL_RULE_FILES) {
+        const fullPath = path.join(basePath, ruleFile);
+        if (fs.existsSync(fullPath)) {
+            return true;
+        }
+    }
+
+    return false;
+}

package/src/tools/arch-tools.ts

@@ -0,0 +1,166 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { AnalyzeDependencyGraphInput } from '../lib/types.js';
+
+/**
+ * Einar's Tool: Architecture Integrity Scanner
+ * Scans the codebase for circular dependencies and structural violations.
+ */
+export async function analyzeDependencyGraph(input: AnalyzeDependencyGraphInput) {
+    // Determine root. Input path is relative to CWD usually.
+    // If input.path is absolute, use it. Otherwise resolve from CWD.
+    const searchPath = path.isAbsolute(input.path)
+        ? input.path
+        : path.resolve(process.cwd(), input.path);
+
+    try {
+        await fs.access(searchPath);
+    } catch {
+        return {
+            error: `Directory not found: ${searchPath}. Ensure you are running the MCP server in the project root or provide an absolute path.`
+        };
+    }
+
+    // 1. Scan files
+    const allFiles = await getAllFiles(searchPath);
+    const tsFiles = allFiles.filter(f => /\.(ts|tsx|js|jsx)$/.test(f) && !f.includes('node_modules') && !f.includes('.next') && !f.includes('dist'));
+
+    // 2. Build Graph
+    const graph: Record<string, string[]> = {};
+    const fileSet = new Set(tsFiles);
+
+    for (const file of tsFiles) {
+        const content = await fs.readFile(file, 'utf-8');
+        const imports = extractImports(content);
+
+        const validDeps: string[] = [];
+
+        for (const imp of imports) {
+            const resolved = resolveImport(file, imp, searchPath);
+            if (resolved && fileSet.has(resolved)) {
+                validDeps.push(resolved);
+            }
+        }
+
+        // Use relative paths for the graph to make it readable
+        const relFile = path.relative(searchPath, file);
+        graph[relFile] = validDeps.map(d => path.relative(searchPath, d));
+    }
+
+    // 3. Detect Cycles
+    const cycles = detectCycles(graph);
+
+    return {
+        timestamp: new Date().toISOString(),
+        analyzedPath: searchPath,
+        metrics: {
+            totalFiles: tsFiles.length,
+            circularDependencies: cycles.length
+        },
+        cycles: cycles,
+        status: cycles.length > 0 ? 'VIOLATION' : 'PASS',
+        summary: cycles.length > 0
+            ? `FAILED. Detected ${cycles.length} circular dependencies. These must be resolved to maintain architectural integrity.`
+            : `PASSED. No circular dependencies detected in ${tsFiles.length} files.`
+    };
+}
+
+// --- Helpers ---
+
+async function getAllFiles(dir: string): Promise<string[]> {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const res = path.resolve(dir, entry.name);
+        return entry.isDirectory() ? getAllFiles(res) : res;
+    }));
+    return files.flat();
+}
+
+/**
+ * Simple regex extraction of import statements.
+ * Matches: import ... from '...'
+ * Matches: import '...'
+ * Matches: export ... from '...'
+ */
+function extractImports(content: string): string[] {
+    const regex = /from\s+['"]([^'"]+)['"]|import\s+['"]([^'"]+)['"]/g;
+    const imports: string[] = [];
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        // match[1] is 'from "..."; match[2] is import "...";
+        imports.push(match[1] || match[2]);
+    }
+    return imports;
+}
+
+/**
+ * Naive resolver.
+ * Handles:
+ * - Relative: ./foo, ../bar
+ * - Alias: @/ -> searchPath/ (Assumes Next.js style)
+ * - Extensions: tries .ts, .tsx, .js, index.ts, etc.
+ */
+function resolveImport(importer: string, importPath: string, root: string): string | null {
+    if (!importPath.startsWith('.') && !importPath.startsWith('@/')) {
+        return null; // Ignore node_modules
+    }
+
+    let searchDir = path.dirname(importer);
+    let target = importPath;
+
+    if (importPath.startsWith('@/')) {
+        target = importPath.replace('@/', '');
+        searchDir = root; // Assume root is where @/ points to (src or project root)
+        // Adjust for src if root includes src, ensuring we don't double dip? 
+        // Actually, usually @/ maps to src/ or root. We'll try relative to 'root'.
+    }
+
+    const startPath = path.resolve(searchDir, target);
+
+    // Try extensions
+    const extensions = ['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js', ''];
+    for (const ext of extensions) {
+        const candidate = startPath + ext;
+        if (require('fs').existsSync(candidate) && !require('fs').statSync(candidate).isDirectory()) {
+            return candidate;
+        }
+    }
+
+    return null;
+}
+
+function detectCycles(graph: Record<string, string[]>): string[][] {
+    const visited = new Set<string>();
+    const recursionStack = new Set<string>();
+    const cycles: string[][] = [];
+
+    function dfs(node: string, path: string[]) {
+        visited.add(node);
+        recursionStack.add(node);
+        path.push(node);
+
+        const deps = graph[node] || [];
+        for (const dep of deps) {
+            if (!visited.has(dep)) {
+                dfs(dep, path);
+            } else if (recursionStack.has(dep)) {
+                // Cycle detected
+                const cycleStart = path.indexOf(dep);
+                if (cycleStart !== -1) {
+                    cycles.push([...path.slice(cycleStart), dep]);
+                }
+            }
+        }
+
+        recursionStack.delete(node);
+        path.pop();
+    }
+
+    for (const node of Object.keys(graph)) {
+        if (!visited.has(node)) {
+            dfs(node, []);
+        }
+    }
+
+    return cycles;
+}

package/src/tools/archaeological-scan.ts

@@ -0,0 +1,335 @@
+
+import { SupabaseClient } from '@supabase/supabase-js';
+
+/**
+ * Brynjar's Archaeological Scan Tool
+ * 
+ * Analyzes Git history and file structure to reconstruct
+ * a project's historical context and generate "Ghost Features"
+ * that represent completed work.
+ */
+
+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[];
+}
+
+/**
+ * Fetch Brynjar's persona from the system_prompts table
+ */
+export async function getBrynjarPersona(supabase: SupabaseClient) {
+    const { data: persona, error } = await supabase
+        .from('system_prompts')
+        .select('*')
+        .eq('slug', 'brynjar')
+        .single();
+
+    if (error || !persona) {
+        return {
+            display_name: 'Brynjar',
+            job_title: 'The Librarian / Project Archivist',
+            content: 'You are Brynjar, the Project Archivist specialized in reconstructing project history.'
+        };
+    }
+
+    return persona;
+}
+
+/**
+ * Parse git log output into structured commits
+ */
+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
+ */
+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
+ */
+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
+ */
+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;
+}
+
+/**
+ * Main archaeological scan function
+ * Called by the MCP server when Brynjar is invoked
+ */
+export async function performArchaeologicalScan(
+    supabase: SupabaseClient,
+    projectId: string,
+    gitLog: string,
+    fileTree: string[]
+): Promise<ArchaeologicalReport> {
+    console.error(`🏛️ Brynjar is performing an archaeological scan for project ${projectId}...`);
+
+    // Parse git history
+    const commits = parseGitLog(gitLog);
+    const milestones = identifyMilestones(commits);
+
+    // Analyze filesystem
+    const filesystemAnalysis = analyzeFilesystem(fileTree);
+
+    // Generate ghost features
+    const discoveredFeatures = generateDiscoveredFeatures(milestones, filesystemAnalysis);
+
+    // Generate recommendations
+    const recommendations: string[] = [];
+
+    if (milestones.length === 0) {
+        recommendations.push('No significant milestones detected. Consider adding more descriptive commit messages.');
+    }
+    if (filesystemAnalysis.featureDirectories.length < 3) {
+        recommendations.push('Project structure appears simple. This may be intentional or early-stage.');
+    }
+    if (discoveredFeatures.length > 0) {
+        recommendations.push(`${discoveredFeatures.length} ghost features ready for import into the roadmap.`);
+    }
+    if (!filesystemAnalysis.configFiles.some(f => f.includes('supabase'))) {
+        recommendations.push('No Supabase configuration detected. Database integration may be pending.');
+    }
+
+    const report: ArchaeologicalReport = {
+        projectId,
+        scanDate: new Date().toISOString(),
+        gitAnalysis: {
+            totalCommits: commits.length,
+            analyzedCommits: Math.min(commits.length, 100),
+            milestones
+        },
+        filesystemAnalysis: {
+            totalDirectories: fileTree.filter(f => !f.includes('.')).length,
+            ...filesystemAnalysis
+        },
+        discoveredFeatures,
+        recommendations
+    };
+
+    console.error(`🏛️ Brynjar found ${discoveredFeatures.length} ghost features and ${milestones.length} milestones.`);
+
+    return report;
+}
+
+/**
+ * Import ghost features into the roadmap as COMPLETED chunks
+ */
+export async function importGhostFeatures(
+    supabase: SupabaseClient,
+    projectId: string,
+    features: DiscoveredFeature[]
+): Promise<{ success: boolean; imported: number; errors: string[] }> {
+    console.error(`🏛️ Brynjar is importing ${features.length} ghost features into the roadmap...`);
+
+    const errors: string[] = [];
+    let imported = 0;
+
+    for (const feature of features) {
+        const { error } = await supabase
+            .from('roadmap_chunks')
+            .insert({
+                project_id: projectId,
+                title: feature.title,
+                description: feature.description,
+                status: 'COMPLETED',
+                priority: feature.priority,
+                is_legacy: true, // Mark as reconstructed historical feature
+                completed_at: feature.estimatedCompletionDate, // Original completion date from Git
+                created_at: new Date().toISOString(), // Import timestamp
+                updated_at: new Date().toISOString()
+            });
+
+        if (error) {
+            errors.push(`Failed to import "${feature.title}": ${error.message}`);
+        } else {
+            imported++;
+        }
+    }
+
+    console.error(`🏛️ Brynjar imported ${imported}/${features.length} ghost features.`);
+
+    return { success: errors.length === 0, imported, errors };
+}