@rigstate/mcp 0.4.2

package/src/tools/ui-tools.ts

@@ -0,0 +1,191 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { AnalyzeUiComponentInput, ApplyDesignSystemInput, FetchUiLibraryDocsInput } from '../lib/types.js';
+
+/**
+ * Linus's Tool: Analyze UI Component
+ * Checks for design deviations, hardcoded values, and accessibility gaps.
+ */
+export async function analyzeUiComponent(input: AnalyzeUiComponentInput) {
+    const { filePath } = input;
+
+    if (!await fileExists(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+
+    const content = await fs.readFile(filePath, 'utf-8');
+    const issues: string[] = [];
+    const score = 100;
+
+    // 1. Check for Hardcoded Hex Colors
+    // Regex matches text-[#...], bg-[#...], or just #... inside classNames often
+    const hexRegex = /#([0-9A-Fa-f]{3}){1,2}\b/g;
+    const hexMatches = content.match(hexRegex);
+    if (hexMatches) {
+        // Filter out ID selectors in CSS if file is .css
+        const isCss = filePath.endsWith('.css');
+        const uniqueHex = [...new Set(hexMatches)];
+
+        for (const hex of uniqueHex) {
+            // In CSS, #id is valid. In TSX className, usually implies hardcoded color.
+            if (!isCss || content.includes(`color: ${hex}`) || content.includes(`background: ${hex}`)) {
+                issues.push(`Hardcoded color found: ${hex}. Use design tokens (e.g., bg-background, text-primary).`);
+            }
+        }
+    }
+
+    // 2. Check for missing Alt text on images (TSX only)
+    if (filePath.endsWith('.tsx')) {
+        const imgRegex = /<img(?![^>]*\balt=)[^>]*>/g;
+        if (imgRegex.test(content)) {
+            issues.push('Accessibility: <img> tag detected without "alt" attribute.');
+        }
+
+        // Check for Image component (Next.js)
+        const nextImgRegex = /<Image(?![^>]*\balt=)[^>]*>/g;
+        if (nextImgRegex.test(content)) {
+            issues.push('Accessibility: <Image> component missing "alt" prop.');
+        }
+    }
+
+    // 3. Check for arbitrary values (Tailwind)
+    // Matches w-[123px] or p-[10px] etc.
+    const arbitraryRegex = /\w-\[\d+px\]/g;
+    if (arbitraryRegex.test(content)) {
+        issues.push('maintainability: Arbitrary pixel values detected (e.g., w-[50px]). Use standard spacing scale (w-12).');
+    }
+
+    return {
+        filePath: path.basename(filePath),
+        issueCount: issues.length,
+        issues: issues.length > 0 ? issues : ['✅ No obvious design violations found. Great job!']
+    };
+}
+
+/**
+ * Linus's Tool: Apply Design System
+ * Auto-fixes common design system violations (e.g. replacing hardcoded logic).
+ */
+export async function applyDesignSystem(input: ApplyDesignSystemInput) {
+    const { filePath } = input;
+
+    if (!await fileExists(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+
+    let content = await fs.readFile(filePath, 'utf-8');
+    let replacements = 0;
+
+    // Mapping of hardcoded values to System Tokens
+    // Determine context (light/dark agnostic logic)
+    const adjustments = [
+        // Text Colors
+        { pattern: /text-\[#000000\]/g, replacement: 'text-foreground' },
+        { pattern: /text-\[#000\]/g, replacement: 'text-foreground' },
+        { pattern: /text-\[#ffffff\]/g, replacement: 'text-primary-foreground' },
+        { pattern: /text-\[#fff\]/g, replacement: 'text-primary-foreground' },
+
+        // Backgrounds
+        { pattern: /bg-\[#ffffff\]/g, replacement: 'bg-background' },
+        { pattern: /bg-\[#fff\]/g, replacement: 'bg-background' },
+        { pattern: /bg-\[#000000\]/g, replacement: 'bg-black' }, // Or bg-foreground? keeping bg-black safe.
+
+        // Borders
+        { pattern: /border-\[#e5e7eb\]/g, replacement: 'border-border' }, // Common gray
+        { pattern: /border-\[#d1d5db\]/g, replacement: 'border-border' },
+    ];
+
+    for (const adj of adjustments) {
+        if (adj.pattern.test(content)) {
+            const matches = content.match(adj.pattern);
+            replacements += matches ? matches.length : 0;
+            content = content.replace(adj.pattern, adj.replacement);
+        }
+    }
+
+    if (replacements > 0) {
+        await fs.writeFile(filePath, content, 'utf-8');
+        return {
+            success: true,
+            filesFixed: 1,
+            replacementsCount: replacements,
+            message: `Applied design system: Replaced ${replacements} hardcoded values with tokens in ${path.basename(filePath)}.`
+        };
+    }
+
+    return {
+        success: true,
+        filesFixed: 0,
+        replacementsCount: 0,
+        message: 'No automatic replacements could be applied. Manual review may be needed.'
+    };
+}
+
+/**
+ * Astrid's Tool: Fetch UI Library Docs
+ * Retrieves reference code for components (Shadcn/UI).
+ */
+export async function fetchUiLibraryDocs(input: FetchUiLibraryDocsInput) {
+    const { componentName, library } = input;
+
+    if (library === 'shadcn') {
+        // Try to find the component in apps/web/src/components/ui
+        // We scan for the file.
+        // Assuming typical monorepo path from root.
+        const basePaths = [
+            '/Users/steinhofve/Documents/Nowhere/CURSOR/Rigstate/apps/web/src/components/ui',
+            path.resolve(process.cwd(), 'apps/web/src/components/ui')
+        ];
+
+        for (const basePath of basePaths) {
+            if (await dirExists(basePath)) {
+                // Try .tsx and .ts
+                const variations = [`${componentName}.tsx`, `${componentName}.ts`, `${componentName}/index.tsx`];
+
+                for (const variant of variations) {
+                    const fullPath = path.join(basePath, variant);
+                    if (await fileExists(fullPath)) {
+                        const content = await fs.readFile(fullPath, 'utf-8');
+                        // Return a truncated/summarized version or full?
+                        // Full is better for "Copy syntax".
+                        return {
+                            found: true,
+                            source: 'Local Component Definition',
+                            path: fullPath,
+                            content: content
+                        };
+                    }
+                }
+            }
+        }
+
+        return {
+            found: false,
+            message: `Component "${componentName}" not found in local Shadcn UI directory.`
+        };
+    }
+
+    return {
+        found: false,
+        message: `Library "${library}" docs access not implemented yet.`
+    };
+}
+
+// Helpers
+async function fileExists(path: string) {
+    try {
+        await fs.access(path);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function dirExists(path: string) {
+    try {
+        const stat = await fs.stat(path);
+        return stat.isDirectory();
+    } catch {
+        return false;
+    }
+}

package/src/tools/update-roadmap.ts

@@ -0,0 +1,105 @@
+/**
+ * Tool: update_roadmap
+ * 
+ * Updates the status of a roadmap chunk (step).
+ * Can search by chunk ID or by title.
+ */
+
+import { SupabaseClient } from '@supabase/supabase-js';
+import type { UpdateRoadmapResponse } from '../lib/types.js';
+
+export async function updateRoadmap(
+    supabase: SupabaseClient,
+    userId: string,
+    projectId: string,
+    status: 'LOCKED' | 'ACTIVE' | 'COMPLETED',
+    chunkId?: string,
+    title?: string
+): Promise<UpdateRoadmapResponse> {
+    // First, verify project ownership
+    const { data: project, error: projectError } = await supabase
+        .from('projects')
+        .select('id, name')
+        .eq('id', projectId)
+        .eq('owner_id', userId)
+        .single();
+
+    if (projectError || !project) {
+        throw new Error('Project not found or access denied');
+    }
+
+    // Find the roadmap chunk
+    let targetChunk: { id: string; title: string; status: string } | null = null;
+
+    if (chunkId) {
+        // Search by ID
+        const { data, error } = await supabase
+            .from('roadmap_chunks')
+            .select('id, title, status')
+            .eq('id', chunkId)
+            .eq('project_id', projectId)
+            .single();
+
+        if (error || !data) {
+            throw new Error(`Roadmap step with ID "${chunkId}" not found`);
+        }
+        targetChunk = data;
+    } else if (title) {
+        // Search by title (fuzzy match using ilike)
+        const { data, error } = await supabase
+            .from('roadmap_chunks')
+            .select('id, title, status')
+            .eq('project_id', projectId)
+            .ilike('title', `%${title}%`)
+            .limit(1)
+            .single();
+
+        if (error || !data) {
+            throw new Error(`Roadmap step matching "${title}" not found`);
+        }
+        targetChunk = data;
+    } else {
+        throw new Error('Either chunkId or title must be provided');
+    }
+
+    const previousStatus = targetChunk.status;
+
+    // Don't update if status is the same
+    if (previousStatus === status) {
+        return {
+            success: true,
+            chunkId: targetChunk.id,
+            previousStatus,
+            newStatus: status,
+            message: `ℹ️ Roadmap step "${targetChunk.title}" is already ${status}`
+        };
+    }
+
+    // Update the status
+    const { error: updateError } = await supabase
+        .from('roadmap_chunks')
+        .update({ status })
+        .eq('id', targetChunk.id);
+
+    if (updateError) {
+        if (updateError.code === '42501') {
+            throw new Error('Permission denied: Cannot update this roadmap');
+        }
+        throw new Error(`Failed to update roadmap: ${updateError.message}`);
+    }
+
+    // Build status transition message
+    const statusEmoji: Record<string, string> = {
+        'LOCKED': '🔒',
+        'ACTIVE': '🚧',
+        'COMPLETED': '✅'
+    };
+
+    return {
+        success: true,
+        chunkId: targetChunk.id,
+        previousStatus,
+        newStatus: status,
+        message: `${statusEmoji[status]} Roadmap step "${targetChunk.title}" updated: ${previousStatus} → ${status}`
+    };
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "lib": [
+            "ES2022"
+        ],
+        "moduleResolution": "bundler",
+        "resolveJsonModule": true,
+        "allowJs": true,
+        "outDir": "dist",
+        "declaration": true,
+        "declarationMap": true,
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "types": [
+            "node"
+        ]
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}

package/tsup.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    format: ['esm'],
+    dts: true,
+    splitting: false,
+    sourcemap: true,
+    clean: true,
+    shims: true,
+    banner: {
+        js: '#!/usr/bin/env node'
+    },
+    minify: false,
+    target: 'node18'
+});