@vibecheckai/cli 2.8.2 → 3.0.0

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

@@ -0,0 +1,119 @@
+/**
+ * GitHub Copilot Instructions Generator
+ * Generates .github/copilot-instructions.md
+ */
+
+/**
+ * Generate Copilot instructions
+ */
+function generateCopilotInstructions(analysis) {
+  const p = analysis.patterns || {};
+  const m = analysis.monorepo || {};
+
+  return `# GitHub Copilot Instructions - ${analysis.name}
+
+## Project Overview
+
+This is a **${analysis.framework || "JavaScript"}** project using **${analysis.language || "JavaScript"}**.
+Architecture: ${analysis.architecture}
+${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 (strict mode)" : ""}
+${analysis.hasPrisma ? "- Prisma ORM" : ""}
+${analysis.hasTailwind ? "- Tailwind CSS" : ""}
+${p.stateManagement ? `- State Management: ${p.stateManagement}` : ""}
+${p.validation ? `- Validation: ${p.validation}` : ""}
+${p.authentication ? `- Authentication: ${p.authentication}` : ""}
+${p.dataFetching?.length ? `- Data Fetching: ${p.dataFetching.join(", ")}` : ""}
+${p.testing?.length ? `- Testing: ${p.testing.join(", ")}` : ""}
+
+## Project Structure
+
+\`\`\`
+${analysis.directories.map(d => `${d}/`).join("\n")}
+\`\`\`
+
+${m.isMonorepo && m.workspaces?.length > 0 ? `## Workspaces
+
+${m.workspaces.slice(0, 8).map(w => `- \`${w.path}\` - ${w.name}`).join("\n")}
+` : ""}
+
+## Existing Components
+
+When generating UI code, prefer using these existing components:
+${analysis.components.slice(0, 25).map(c => `- ${c}`).join("\n") || "None detected"}
+
+${p.hooks?.length > 0 ? `## Custom Hooks
+
+Use these existing hooks instead of creating new ones:
+${p.hooks.slice(0, 15).map(h => `- \`${h}\``).join("\n")}
+` : ""}
+
+## API Routes
+
+${analysis.apiRoutes.slice(0, 15).map(r => `- ${r}`).join("\n") || "None detected"}
+
+${analysis.models.length > 0 ? `## Data Models (Prisma)
+
+${analysis.models.map(m => `- ${m}`).join("\n")}
+` : ""}
+
+${analysis.envVars?.variables?.length > 0 ? `## Environment Variables
+
+Required variables:
+${analysis.envVars.variables.slice(0, 15).map(v => `- \`${v}\``).join("\n")}
+` : ""}
+
+## Code Conventions
+
+### File Naming
+- Components: ${analysis.conventions.naming.components || "PascalCase"} (e.g., \`Button.tsx\`)
+- Utilities: camelCase (e.g., \`formatDate.ts\`)
+- Types: PascalCase with \`.types.ts\` suffix
+
+### Import Aliases
+- Use \`@/\` for src imports (e.g., \`@/components/Button\`)
+- Never use deep relative imports like \`../../../\`
+
+### TypeScript
+${analysis.hasTypescript ? `- Enable strict mode
+- No \`any\` types - use \`unknown\` or proper types
+- Define interfaces for all props and API responses` : "- Use JSDoc comments for type hints"}
+
+## Critical Rules
+
+1. **Security**: Never hardcode API keys, secrets, or credentials
+2. **Types**: ${analysis.hasTypescript ? "No `any` types allowed" : "Use JSDoc for type hints"}
+3. **Components**: Check existing components before creating new ones
+4. **Hooks**: Use existing custom hooks when available
+5. **Validation**: ${p.validation ? `Always validate input with ${p.validation}` : "Always validate user input"}
+6. **Styling**: ${analysis.hasTailwind ? "Use Tailwind CSS classes" : "Follow existing styling patterns"}
+7. **State**: ${p.stateManagement ? `Use ${p.stateManagement} for global state` : "Keep state minimal and local"}
+
+${p.antiPatterns?.length > 0 ? `## Anti-Patterns to Avoid
+
+${p.antiPatterns.map(ap => `- ❌ ${ap.message} → ${ap.suggestion}`).join("\n")}
+` : ""}
+
+## When Writing Code
+
+1. Follow existing patterns in the codebase
+2. Use TypeScript strict types
+3. Add proper error handling
+4. Use existing utilities and helpers
+5. Keep functions small and focused
+6. Write self-documenting code
+
+---
+
+*Context Enhanced by vibecheck AI*
+`;
+}
+
+module.exports = {
+  generateCopilotInstructions,
+};

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,
+};