vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/context/generators/cursor.js

@@ -0,0 +1,514 @@
+/**
+ * Cursor Rules Generator
+ * Generates .cursorrules and .cursor/rules/*.mdc files
+ */
+
+/**
+ * Get directory purpose description
+ */
+function getDirectoryPurpose(dir) {
+  const purposes = {
+    "src": "Source code root",
+    "app": "Next.js App Router pages",
+    "pages": "Next.js Pages Router",
+    "components": "Reusable UI components",
+    "lib": "Utility functions and shared logic",
+    "utils": "Helper functions",
+    "hooks": "Custom React hooks",
+    "services": "API and external service integrations",
+    "api": "API route handlers",
+    "server": "Server-side code",
+    "prisma": "Database schema and migrations",
+    "public": "Static assets",
+    "styles": "CSS and styling",
+    "types": "TypeScript type definitions",
+    "config": "Configuration files",
+    "test": "Test files",
+    "__tests__": "Test files",
+  };
+  return purposes[dir] || "Project files";
+}
+
+/**
+ * Generate main .cursorrules file
+ */
+function generateCursorRules(analysis) {
+  const p = analysis.patterns || {};
+  const t = analysis.types || {};
+  const s = analysis.stats || {};
+  const env = analysis.envVars || {};
+  const m = analysis.monorepo || {};
+  
+  return `# vibecheck AI - Project Context for Cursor
+
+> Auto-generated by \`vibecheck context\`. Regenerate when your codebase changes.
+
+## Project Overview
+
+- **Name**: ${analysis.name}
+- **Framework**: ${analysis.framework || "Unknown"}
+- **Language**: ${analysis.language || "JavaScript"}
+- **Architecture**: ${analysis.architecture}
+${s.totalFiles ? `- **Size**: ${s.totalFiles} files, ~${Math.round(s.totalLines / 1000)}k lines` : ""}
+${m.isMonorepo ? `- **Monorepo**: ${m.type} with ${m.workspaces?.length || 0} workspaces` : ""}
+
+## Tech Stack
+
+${analysis.hasNextjs ? "- Next.js (App Router)" : ""}
+${analysis.hasReact ? "- React" : ""}
+${analysis.hasTypescript ? "- TypeScript" : ""}
+${analysis.hasPrisma ? "- Prisma ORM" : ""}
+${analysis.hasTailwind ? "- Tailwind CSS" : ""}
+${p.stateManagement ? `- State: ${p.stateManagement}` : ""}
+${p.validation ? `- Validation: ${p.validation}` : ""}
+${p.authentication ? `- Auth: ${p.authentication}` : ""}
+${p.dataFetching?.length ? `- Data Fetching: ${p.dataFetching.join(", ")}` : ""}
+
+## Project Structure
+
+\`\`\`
+${analysis.directories.map(d => `${d}/`).join("\n")}
+\`\`\`
+
+${m.isMonorepo && m.workspaces?.length > 0 ? `## Workspaces
+
+${m.workspaces.slice(0, 10).map(w => `- \`${w.path}\` - ${w.name}`).join("\n")}
+` : ""}
+
+${p.hooks?.length > 0 ? `## Custom Hooks (Use These!)
+
+${p.hooks.slice(0, 15).map(h => `- \`${h}\``).join("\n")}
+
+${p.codeExamples?.hooks ? `### Example: ${p.codeExamples.hooks.name}
+\`\`\`typescript
+// From: ${p.codeExamples.hooks.file}
+${p.codeExamples.hooks.code}
+\`\`\`
+` : ""}
+` : ""}
+
+${analysis.apiRoutes.length > 0 ? `## API Routes
+
+${analysis.apiRoutes.slice(0, 20).map(r => `- \`${r}\``).join("\n")}
+${analysis.apiRoutes.length > 20 ? `\n... and ${analysis.apiRoutes.length - 20} more` : ""}
+` : ""}
+
+${analysis.components.length > 0 ? `## Components (Check Before Creating New)
+
+${analysis.components.slice(0, 30).map(c => `- \`${c}\``).join("\n")}
+${analysis.components.length > 30 ? `\n... and ${analysis.components.length - 30} more` : ""}
+` : ""}
+
+${analysis.models.length > 0 ? `## Data Models (Prisma)
+
+${analysis.models.map(m => `- \`${m}\``).join("\n")}
+` : ""}
+
+${t.interfaces?.length > 0 || t.types?.length > 0 ? `## Key Types & Interfaces
+
+${t.interfaces?.slice(0, 15).map(i => `- \`interface ${i}\``).join("\n") || ""}
+${t.types?.slice(0, 10).map(ty => `- \`type ${ty}\``).join("\n") || ""}
+${t.enums?.length > 0 ? `\nEnums: ${t.enums.slice(0, 5).map(e => `\`${e}\``).join(", ")}` : ""}
+` : ""}
+
+${env.variables?.length > 0 ? `## Environment Variables
+
+Required env vars:
+${env.variables.slice(0, 20).map(v => `- \`${v}\``).join("\n")}
+${env.files?.length ? `\nEnv files: ${env.files.join(", ")}` : ""}
+` : ""}
+
+${analysis.scripts?.length > 0 ? `## NPM Scripts
+
+${analysis.scripts.slice(0, 10).map(s => `- \`npm run ${s.name}\` - ${s.command}`).join("\n")}
+` : ""}
+
+## Coding Conventions
+
+### File Naming
+- Components: ${analysis.conventions.naming.components || "PascalCase"} (e.g., \`Button.tsx\`, \`UserCard.tsx\`)
+- Utilities: camelCase (e.g., \`formatDate.ts\`, \`apiClient.ts\`)
+- Types: PascalCase with \`.d.ts\` or \`.types.ts\` suffix
+
+### Import Order
+1. React/Next.js imports
+2. Third-party libraries
+3. Internal components (\`@/components/\`)
+4. Internal utilities (\`@/lib/\`, \`@/utils/\`)
+5. Types
+6. Styles
+
+### Code Style
+- Use ${analysis.hasTypescript ? "TypeScript with strict mode" : "JavaScript with JSDoc comments"}
+- Prefer functional components with hooks
+- Use path aliases (\`@/\`) for imports
+${analysis.hasTailwind ? "- Use Tailwind CSS for styling (no inline styles)" : ""}
+${analysis.hasPrisma ? "- Use Prisma client for database operations" : ""}
+${p.stateManagement ? `- Use ${p.stateManagement} for state management` : ""}
+${p.validation ? `- Use ${p.validation} for input validation` : ""}
+
+## Critical Rules
+
+1. **Never hardcode secrets** - Use environment variables
+2. **No mock data in production** - Check for \`demo\`, \`fake\`, \`mock\` patterns
+3. **Type everything** - No \`any\` types${analysis.hasTypescript ? "" : " (use JSDoc)"}
+4. **Follow existing patterns** - Match the codebase style
+5. **Use existing components** - Don't recreate what exists
+6. **API routes must validate input** - Never trust client data
+${p.hooks?.length ? `7. **Use existing hooks** - Check custom hooks list above` : ""}
+
+${p.antiPatterns?.length > 0 ? `## ⚠️ Avoid These Patterns
+
+${p.antiPatterns.map(ap => `- **${ap.message}** - ${ap.suggestion}`).join("\n")}
+` : ""}
+
+## When Creating New Files
+
+1. Check if similar file exists first
+2. Place in correct directory based on type
+3. Follow naming conventions
+4. Import from correct paths
+5. Add proper types/interfaces
+${p.hooks?.length ? `6. Check if there's an existing hook you can use` : ""}
+
+---
+
+*Context Enhanced by vibecheck AI*
+`;
+}
+
+/**
+ * Generate modular Cursor rules (.cursor/rules/*.mdc)
+ */
+function generateCursorModularRules(analysis) {
+  const rules = {};
+  const p = analysis.patterns || {};
+  const t = analysis.types || {};
+  const env = analysis.envVars || {};
+  const m = analysis.monorepo || {};
+
+  // Architecture rules
+  rules["architecture"] = `---
+description: Project architecture and structure guidelines
+globs: ["**/*.{ts,tsx,js,jsx}"]
+alwaysApply: true
+---
+
+# Architecture Guidelines
+
+## Project Type: ${analysis.architecture}
+
+${analysis.hasNextjs ? `### Next.js App Router Structure
+- Pages go in \`app/\` directory
+- API routes in \`app/api/\`
+- Layouts use \`layout.tsx\`
+- Loading states use \`loading.tsx\`
+- Error boundaries use \`error.tsx\`
+` : ""}
+
+${m.isMonorepo ? `### Monorepo Structure (${m.type})
+
+Workspaces:
+${m.workspaces?.slice(0, 8).map(w => `- \`${w.path}\` - ${w.name}`).join("\n") || "None detected"}
+
+${m.sharedPackages?.length > 0 ? `Shared Packages:
+${m.sharedPackages.slice(0, 5).map(p => `- ${p.name} (used in ${p.usedIn} workspaces)`).join("\n")}` : ""}
+` : ""}
+
+### Directory Purpose
+${analysis.directories.map(d => `- \`${d}/\` - ${getDirectoryPurpose(d)}`).join("\n")}
+
+### Import Aliases
+- Use \`@/\` for src directory imports
+- Never use relative imports deeper than \`../\`
+`;
+
+  // Data flow rules
+  if (analysis.hasPrisma || analysis.apiRoutes.length > 0 || p.dataFetching?.length) {
+    rules["data-flow"] = `---
+description: Data fetching and API interaction patterns
+globs: ["**/api/**", "**/lib/**", "**/services/**", "**/hooks/**"]
+alwaysApply: false
+---
+
+# Data Flow Guidelines
+
+${p.dataFetching?.length ? `## Data Fetching: ${p.dataFetching.join(", ")}
+
+${p.dataFetching.includes("TanStack Query") ? `### TanStack Query Pattern
+- Use \`useQuery\` for GET requests
+- Use \`useMutation\` for POST/PUT/DELETE
+- Define query keys consistently
+- Invalidate queries after mutations
+` : ""}
+${p.dataFetching.includes("SWR") ? `### SWR Pattern
+- Use \`useSWR\` for data fetching
+- Define fetcher functions
+- Handle loading and error states
+` : ""}
+${p.dataFetching.includes("tRPC") ? `### tRPC Pattern
+- Use tRPC procedures for type-safe API calls
+- Define routers in \`server/api/routers\`
+- Use \`api.*.useQuery()\` pattern
+` : ""}
+` : ""}
+
+${analysis.hasPrisma ? `## Database (Prisma)
+
+Models: ${analysis.models.join(", ")}
+
+Rules:
+- Use Prisma client from \`@/lib/prisma\` or \`@/server/db\`
+- Use transactions for multi-step operations
+- Handle errors with try/catch
+- Never expose raw database errors
+` : ""}
+
+${analysis.apiRoutes.length > 0 ? `## API Routes
+
+${analysis.apiRoutes.slice(0, 15).map(r => `- ${r}`).join("\n")}
+
+Rules:
+${p.validation ? `- Validate all input with ${p.validation}` : "- Validate all input"}
+- Return consistent response shapes
+- Use proper HTTP status codes
+` : ""}
+`;
+  }
+
+  // Component rules
+  if (analysis.components.length > 0) {
+    rules["components"] = `---
+description: Component creation and styling guidelines  
+globs: ["**/components/**/*.{tsx,jsx}"]
+alwaysApply: false
+---
+
+# Component Guidelines
+
+## Existing Components (${analysis.components.length})
+${analysis.components.slice(0, 20).map(c => `- \`${c}\``).join("\n")}
+
+## Before Creating New Components
+
+1. **Check if it exists above**
+2. Place in \`components/\` or feature folder
+3. Use ${analysis.conventions.naming.components || "PascalCase"} naming
+4. Export as named export
+${analysis.hasTailwind ? "5. Use Tailwind CSS for styling" : ""}
+${p.styling?.length ? `6. Styling: ${p.styling.join(", ")}` : ""}
+
+## Component Template
+
+\`\`\`tsx
+interface Props {
+  // Define props with types
+}
+
+export function ComponentName({ ...props }: Props) {
+  return (
+    // JSX
+  );
+}
+\`\`\`
+`;
+  }
+
+  // Hooks rules
+  if (p.hooks?.length > 0) {
+    rules["hooks"] = `---
+description: Custom hooks patterns and usage
+globs: ["**/hooks/**/*.{ts,tsx}", "**/use*.{ts,tsx}"]
+alwaysApply: false
+---
+
+# Custom Hooks
+
+## Available Hooks (${p.hooks.length})
+
+${p.hooks.map(h => `- \`${h}\``).join("\n")}
+
+## Before Creating a New Hook
+
+1. **Check the list above first**
+2. Name it \`use[Feature]\`
+3. Place in \`hooks/\` or \`lib/hooks/\`
+4. Return a consistent shape
+
+${p.codeExamples?.hooks ? `## Example
+
+\`\`\`typescript
+// ${p.codeExamples.hooks.file}
+${p.codeExamples.hooks.code}
+\`\`\`
+` : ""}
+`;
+  }
+
+  // State management rules
+  if (p.stateManagement) {
+    rules["state"] = `---
+description: State management patterns
+globs: ["**/store/**", "**/state/**", "**/context/**"]
+alwaysApply: false
+---
+
+# State Management: ${p.stateManagement}
+
+${p.stateManagement === "Zustand" ? `## Zustand Pattern
+
+\`\`\`typescript
+import { create } from 'zustand'
+
+interface Store {
+  count: number
+  increment: () => void
+}
+
+export const useStore = create<Store>((set) => ({
+  count: 0,
+  increment: () => set((state) => ({ count: state.count + 1 })),
+}))
+\`\`\`
+
+- Create stores in \`store/\` directory
+- Use typed store interfaces
+- Keep stores focused and small
+` : ""}
+${p.stateManagement === "Redux Toolkit" ? `## Redux Toolkit Pattern
+
+\`\`\`typescript
+import { createSlice } from '@reduxjs/toolkit'
+
+const slice = createSlice({
+  name: 'feature',
+  initialState: {},
+  reducers: {}
+})
+\`\`\`
+
+- Use createSlice for reducers
+- Use createAsyncThunk for async
+` : ""}
+${p.stateManagement === "React Context" ? `## Context Pattern
+
+\`\`\`typescript
+const Context = createContext<Type | null>(null)
+
+export function useFeature() {
+  const context = useContext(Context)
+  if (!context) throw new Error('Must be used within Provider')
+  return context
+}
+\`\`\`
+` : ""}
+`;
+  }
+
+  // Types rules
+  if (t.interfaces?.length > 0 || t.types?.length > 0) {
+    rules["types"] = `---
+description: Type definitions and interfaces
+globs: ["**/*.d.ts", "**/types/**", "**/*.types.ts"]
+alwaysApply: false
+---
+
+# Type Definitions
+
+## Interfaces (${t.interfaces?.length || 0})
+${t.interfaces?.slice(0, 20).map(i => `- \`${i}\``).join("\n") || "None"}
+
+## Types (${t.types?.length || 0})
+${t.types?.slice(0, 15).map(ty => `- \`${ty}\``).join("\n") || "None"}
+
+${t.enums?.length > 0 ? `## Enums
+${t.enums.map(e => `- \`${e}\``).join("\n")}` : ""}
+
+## Conventions
+- Interfaces for object shapes
+- Type aliases for unions
+- No \`any\` - use \`unknown\`
+`;
+  }
+
+  // Environment rules
+  if (env.variables?.length > 0) {
+    rules["environment"] = `---
+description: Environment variables
+globs: ["**/*.env*", "**/config/**"]
+alwaysApply: false
+---
+
+# Environment Variables (${env.variables?.length || 0})
+
+${env.variables?.slice(0, 25).map(v => `- \`${v}\``).join("\n")}
+
+## Rules
+- Never commit \`.env\` files
+- Access via \`process.env.VAR_NAME\`
+- Prefix client-side vars with \`NEXT_PUBLIC_\`
+`;
+  }
+
+  // Anti-patterns rules
+  if (p.antiPatterns?.length > 0) {
+    rules["avoid"] = `---
+description: Patterns to avoid
+globs: ["**/*.{ts,tsx,js,jsx}"]
+alwaysApply: true
+---
+
+# ⚠️ Patterns to Avoid
+
+${p.antiPatterns.map(ap => `## ${ap.severity === 'error' ? '🔴' : '🟡'} ${ap.message}
+**Fix:** ${ap.suggestion}
+`).join("\n")}
+
+## General
+- ❌ No \`any\` type
+- ❌ No hardcoded secrets
+- ❌ No console.log in production
+- ❌ No mock data in production
+`;
+  }
+
+  // Testing rules
+  if (p.testing?.length > 0) {
+    rules["testing"] = `---
+description: Testing patterns
+globs: ["**/*.test.{ts,tsx}", "**/*.spec.{ts,tsx}"]
+alwaysApply: false
+---
+
+# Testing: ${p.testing.join(", ")}
+
+${p.testing.includes("Jest") || p.testing.includes("Vitest") ? `## Unit Tests
+
+\`\`\`typescript
+describe('Feature', () => {
+  it('should work', () => {
+    expect(result).toBe('expected')
+  })
+})
+\`\`\`
+` : ""}
+${p.testing.includes("Playwright") ? `## E2E Tests
+
+\`\`\`typescript
+test('user flow', async ({ page }) => {
+  await page.goto('/')
+  await page.click('button')
+})
+\`\`\`
+` : ""}
+`;
+  }
+
+  return rules;
+}
+
+module.exports = {
+  generateCursorRules,
+  generateCursorModularRules,
+  getDirectoryPurpose,
+};

package/bin/runners/context/generators/mcp.js

@@ -0,0 +1,169 @@
+/**
+ * MCP Context JSON Generator
+ * Generates .vibecheck/context.json for MCP servers
+ * 
+ * Uses the unified EVIDENCE_SCHEMA and TRUTH_CONTRACT from proof-context.js
+ */
+
+const { EVIDENCE_SCHEMA, TRUTH_CONTRACT } = require("../proof-context.js");
+
+// Context attribution message shown when AI uses vibecheck data
+const CONTEXT_ATTRIBUTION = "🧠 Context enhanced by vibecheck";
+
+/**
+ * Generate universal context JSON for MCP
+ */
+function generateContextJson(analysis, projectPath) {
+  const p = analysis.patterns || {};
+  const m = analysis.monorepo || {};
+
+  return JSON.stringify({
+    version: "3.0.0",
+    generatedAt: new Date().toISOString(),
+    generator: "vibecheck-context",
+    // Reference the unified schema from proof-context.js
+    evidenceSchema: EVIDENCE_SCHEMA,
+    truthContract: TRUTH_CONTRACT,
+    
+    project: {
+      name: analysis.name,
+      path: projectPath,
+      framework: analysis.framework,
+      language: analysis.language,
+      architecture: analysis.architecture,
+    },
+
+    techStack: {
+      nextjs: analysis.hasNextjs,
+      react: analysis.hasReact,
+      typescript: analysis.hasTypescript,
+      prisma: analysis.hasPrisma,
+      tailwind: analysis.hasTailwind,
+      stateManagement: p.stateManagement,
+      validation: p.validation,
+      authentication: p.authentication,
+      dataFetching: p.dataFetching || [],
+      testing: p.testing || [],
+      styling: p.styling || [],
+    },
+
+    structure: {
+      directories: analysis.directories,
+      components: analysis.components,
+      apiRoutes: analysis.apiRoutes,
+      models: analysis.models,
+    },
+
+    patterns: {
+      hooks: p.hooks || [],
+      stateManagement: p.stateManagement,
+      validation: p.validation,
+      authentication: p.authentication,
+      dataFetching: p.dataFetching || [],
+      styling: p.styling || [],
+      testing: p.testing || [],
+      codeExamples: p.codeExamples || {},
+    },
+
+    antiPatterns: p.antiPatterns || [],
+
+    types: {
+      interfaces: analysis.types?.interfaces || [],
+      types: analysis.types?.types || [],
+      enums: analysis.types?.enums || [],
+    },
+
+    environment: {
+      files: analysis.envVars?.files || [],
+      variables: analysis.envVars?.variables || [],
+    },
+
+    scripts: analysis.scripts || [],
+
+    conventions: {
+      naming: analysis.conventions?.naming || {},
+      imports: analysis.imports?.importPatterns || [],
+    },
+
+    monorepo: m.isMonorepo ? {
+      type: m.type,
+      tools: m.tools || [],
+      workspaces: m.workspaces?.map(w => ({
+        name: w.name,
+        path: w.path,
+        description: w.description,
+      })) || [],
+      sharedPackages: m.sharedPackages || [],
+    } : null,
+
+    stats: {
+      totalFiles: analysis.stats?.totalFiles || 0,
+      totalLines: analysis.stats?.totalLines || 0,
+      byExtension: analysis.stats?.byExtension || {},
+      largestFiles: analysis.stats?.largestFiles || [],
+    },
+    contextValidation: analysis.contextValidation || null,
+    contextDrift: analysis.contextDrift || null,
+    contextSummary: analysis.contextSummary || null,
+
+    rules: {
+      critical: [
+        "Never hardcode secrets - use environment variables",
+        "No mock data in production code",
+        `No 'any' types - use proper TypeScript types`,
+        "Follow existing patterns in the codebase",
+        "Use existing components before creating new ones",
+        "API routes must validate all input",
+      ],
+      style: [
+        `File naming: ${analysis.conventions?.naming?.components || "PascalCase"} for components`,
+        "Use path aliases (@/) for imports",
+        analysis.hasTailwind ? "Use Tailwind CSS for styling" : null,
+        p.stateManagement ? `Use ${p.stateManagement} for state management` : null,
+        p.validation ? `Use ${p.validation} for validation` : null,
+      ].filter(Boolean),
+    },
+
+    mcp: {
+      resources: [
+        {
+          uri: `file://${projectPath}/.vibecheck/context.json`,
+          name: "Project Context",
+          description: "Full project analysis and context",
+          mimeType: "application/json",
+        },
+        {
+          uri: `file://${projectPath}/.vibecheck/project-map.json`,
+          name: "Project Map",
+          description: "Complete project structure map",
+          mimeType: "application/json",
+        },
+        {
+          uri: `file://${projectPath}/.vibecheck/memory.json`,
+          name: "AI Memory",
+          description: "AI learning memory for this project",
+          mimeType: "application/json",
+        },
+      ],
+      tools: [
+        {
+          name: "vibecheck.context",
+          description: "Regenerate project context",
+        },
+        {
+          name: "vibecheck.analyze",
+          description: "Analyze specific file or directory",
+        },
+      ],
+    },
+
+    // Attribution message for AI responses
+    _attribution: CONTEXT_ATTRIBUTION,
+    _attributionNote: "Include this attribution when referencing vibecheck context in responses",
+  }, null, 2);
+}
+
+module.exports = {
+  generateContextJson,
+  CONTEXT_ATTRIBUTION,
+};