@vibecheckai/cli 2.8.2 → 3.0.0

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

@@ -0,0 +1,151 @@
+/**
+ * MCP Context JSON Generator
+ * Generates .vibecheck/context.json for MCP servers
+ */
+
+/**
+ * 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",
+    
+    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 || [],
+    },
+
+    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",
+        },
+      ],
+    },
+  }, null, 2);
+}
+
+module.exports = {
+  generateContextJson,
+};

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

@@ -0,0 +1,180 @@
+/**
+ * Windsurf Rules Generator
+ * Generates .windsurf/rules/*.md files for Windsurf Cascade
+ */
+
+/**
+ * Generate Windsurf rules files
+ */
+function generateWindsurfRules(analysis) {
+  const rules = {};
+  const p = analysis.patterns || {};
+  const m = analysis.monorepo || {};
+
+  // Project context
+  rules["project-context"] = `# Project Context - ${analysis.name}
+
+## Overview
+- **Framework:** ${analysis.framework || "Unknown"}
+- **Language:** ${analysis.language || "JavaScript"}
+- **Architecture:** ${analysis.architecture}
+${m.isMonorepo ? `- **Monorepo:** ${m.type} with ${m.workspaces?.length || 0} workspaces` : ""}
+
+## Tech Stack
+${analysis.hasNextjs ? "- Next.js" : ""}
+${analysis.hasReact ? "- React" : ""}
+${analysis.hasTypescript ? "- TypeScript" : ""}
+${analysis.hasPrisma ? "- Prisma ORM" : ""}
+${analysis.hasTailwind ? "- Tailwind CSS" : ""}
+${p.stateManagement ? `- ${p.stateManagement}` : ""}
+${p.validation ? `- ${p.validation}` : ""}
+${p.authentication ? `- ${p.authentication}` : ""}
+
+## Directory 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")}
+` : ""}
+
+## Components (${analysis.components.length})
+${analysis.components.slice(0, 25).map(c => `- ${c}`).join("\n") || "None detected"}
+
+${p.hooks?.length > 0 ? `## Custom Hooks (${p.hooks.length})
+${p.hooks.slice(0, 15).map(h => `- \`${h}\``).join("\n")}
+` : ""}
+
+## API Routes (${analysis.apiRoutes.length})
+${analysis.apiRoutes.slice(0, 15).map(r => `- ${r}`).join("\n") || "None detected"}
+
+${analysis.models.length > 0 ? `## Data Models
+${analysis.models.map(m => `- ${m}`).join("\n")}
+` : ""}
+
+${analysis.envVars?.variables?.length > 0 ? `## Environment Variables
+${analysis.envVars.variables.slice(0, 15).map(v => `- \`${v}\``).join("\n")}
+` : ""}
+
+---
+*Context Enhanced by vibecheck AI*
+`;
+
+  // Coding standards
+  rules["coding-standards"] = `# Coding Standards
+
+## File Naming
+- Components: ${analysis.conventions.naming.components || "PascalCase"} (e.g., \`Button.tsx\`)
+- Utilities: camelCase (e.g., \`formatDate.ts\`)
+- Types: \`.types.ts\` or \`.d.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
+${analysis.hasTypescript ? "- TypeScript with strict mode enabled" : "- JavaScript with JSDoc comments"}
+- Functional components with hooks
+- Path aliases (\`@/\`) for imports
+${analysis.hasTailwind ? "- Tailwind CSS for styling" : ""}
+${p.stateManagement ? `- ${p.stateManagement} for state management` : ""}
+${p.validation ? `- ${p.validation} for validation` : ""}
+
+## Critical Rules
+
+1. **No hardcoded secrets** - Use environment variables
+2. **No \`any\` types** - Use proper TypeScript types
+3. **No mock data in production** - Real API endpoints only
+4. **Validate all inputs** - Never trust client data
+5. **Use existing components** - Check before creating new ones
+${p.hooks?.length ? `6. **Use existing hooks** - ${p.hooks.slice(0, 3).join(", ")}...` : ""}
+
+${p.antiPatterns?.length > 0 ? `## ⚠️ Avoid These
+${p.antiPatterns.map(ap => `- ${ap.message}: ${ap.suggestion}`).join("\n")}
+` : ""}
+
+## When Creating New Files
+1. Check if similar file exists
+2. Place in correct directory
+3. Follow naming conventions
+4. Add proper types
+5. Use existing patterns
+`;
+
+  // API patterns
+  if (analysis.apiRoutes.length > 0 || analysis.hasPrisma) {
+    rules["api-patterns"] = `# API & Data Patterns
+
+${analysis.hasPrisma ? `## Database (Prisma)
+
+### Available Models
+${analysis.models.map(m => `- ${m}`).join("\n")}
+
+### Usage
+\`\`\`typescript
+import { prisma } from '@/lib/prisma'
+
+// Query
+const users = await prisma.user.findMany()
+
+// Create with validation
+const user = await prisma.user.create({
+  data: validatedInput
+})
+\`\`\`
+
+### Rules
+- Always import from \`@/lib/prisma\`
+- Use transactions for multi-step operations
+- Handle errors gracefully
+- Never expose raw errors to client
+` : ""}
+
+${analysis.apiRoutes.length > 0 ? `## API Routes
+
+### Existing Endpoints
+${analysis.apiRoutes.slice(0, 20).map(r => `- \`${r}\``).join("\n")}
+
+### API Response Pattern
+\`\`\`typescript
+// Success
+return Response.json({ data, success: true })
+
+// Error
+return Response.json({ error: message }, { status: 400 })
+\`\`\`
+
+### Validation
+${p.validation ? `Use ${p.validation} for input validation:
+\`\`\`typescript
+const schema = z.object({ name: z.string() })
+const data = schema.parse(await req.json())
+\`\`\`` : "Always validate input before processing"}
+` : ""}
+
+${p.dataFetching?.length ? `## Data Fetching: ${p.dataFetching.join(", ")}
+
+${p.dataFetching.includes("TanStack Query") ? `### TanStack Query
+\`\`\`typescript
+const { data, isLoading } = useQuery({
+  queryKey: ['resource'],
+  queryFn: fetchResource,
+})
+\`\`\`` : ""}
+${p.dataFetching.includes("SWR") ? `### SWR
+\`\`\`typescript
+const { data, error } = useSWR('/api/resource', fetcher)
+\`\`\`` : ""}
+` : ""}
+`;
+  }
+
+  return rules;
+}
+
+module.exports = {
+  generateWindsurfRules,
+};

package/bin/runners/context/git-context.js

@@ -0,0 +1,302 @@
+/**
+ * Git-Aware Context Module
+ * Extracts commit patterns, branch conventions, and PR templates
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+/**
+ * Check if directory is a git repository
+ */
+function isGitRepo(projectPath) {
+  return fs.existsSync(path.join(projectPath, ".git"));
+}
+
+/**
+ * Execute git command safely
+ */
+function execGit(command, cwd = process.cwd()) {
+  try {
+    return execSync(command, { cwd, encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get recent commits with patterns
+ */
+function getRecentCommits(projectPath, limit = 20) {
+  if (!isGitRepo(projectPath)) return null;
+  
+  const output = execGit(`log --oneline -${limit}`, projectPath);
+  if (!output) return null;
+  
+  const commits = output.split("\n").map(line => {
+    const [hash, ...messageParts] = line.split(" ");
+    const message = messageParts.join(" ");
+    
+    // Detect patterns
+    const patterns = {
+      hasTicket: /(FEAT|FIX|CHORE|DOCS|REFACTOR|TEST|PERF)-\d+/i.test(message),
+      ticketType: message.match(/(FEAT|FIX|CHORE|DOCS|REFACTOR|TEST|PERF)-\d+/i)?.[1],
+      isBreaking: /BREAKING CHANGE/i.test(message),
+      hasScope: /\([^)]+\):/.test(message),
+      scope: message.match(/\(([^)]+)\):/)?.[1],
+      isWIP: /wip|work in progress/i.test(message),
+      isMerge: /^Merge /i.test(message),
+    };
+    
+    return {
+      hash,
+      message,
+      patterns,
+    };
+  });
+  
+  // Analyze patterns
+  const analysis = {
+    totalCommits: commits.length,
+    withTickets: commits.filter(c => c.patterns.hasTicket).length,
+    breakingChanges: commits.filter(c => c.patterns.isBreaking).length,
+    withScopes: commits.filter(c => c.patterns.hasScope).length,
+    commonScopes: {},
+    ticketTypes: {},
+  };
+  
+  // Count common patterns
+  for (const commit of commits) {
+    if (commit.patterns.scope) {
+      analysis.commonScopes[commit.patterns.scope] = (analysis.commonScopes[commit.patterns.scope] || 0) + 1;
+    }
+    if (commit.patterns.ticketType) {
+      analysis.ticketTypes[commit.patterns.ticketType] = (analysis.ticketTypes[commit.patterns.ticketType] || 0) + 1;
+    }
+  }
+  
+  return {
+    commits,
+    analysis,
+  };
+}
+
+/**
+ * Get branch information and conventions
+ */
+function getBranchInfo(projectPath) {
+  if (!isGitRepo(projectPath)) return null;
+  
+  const currentBranch = execGit("branch --show-current", projectPath);
+  const allBranches = execGit("branch -a", projectPath);
+  const defaultBranch = execGit("symbolic-ref refs/remotes/origin/HEAD | sed 's@^.*/@@'", projectPath);
+  
+  if (!currentBranch || !allBranches) return null;
+  
+  const branches = allBranches.split("\n").map(b => b.replace("*", "").trim());
+  const localBranches = branches.filter(b => !b.startsWith("remotes/"));
+  const remoteBranches = branches.filter(b => b.startsWith("remotes/")).map(b => b.replace("remotes/origin/", ""));
+  
+  // Analyze naming patterns
+  const patterns = {
+    hasFeaturePrefix: localBranches.some(b => /^feature\//.test(b)),
+    hasBugfixPrefix: localBranches.some(b => /^bugfix\//.test(b) || /^fix\//.test(b)),
+    hasHotfixPrefix: localBranches.some(b => /^hotfix\//.test(b)),
+    hasIssueNumber: localBranches.some(b => /\d+$/.test(b)),
+    usesSlashes: localBranches.some(b => b.includes("/")),
+    usesKebabCase: localBranches.some(b => /-/.test(b)),
+  };
+  
+  // Common prefixes
+  const prefixes = {};
+  for (const branch of localBranches) {
+    if (branch.includes("/")) {
+      const prefix = branch.split("/")[0];
+      prefixes[prefix] = (prefixes[prefix] || 0) + 1;
+    }
+  }
+  
+  return {
+    current: currentBranch,
+    default: defaultBranch,
+    total: localBranches.length,
+    local: localBranches,
+    remote: remoteBranches,
+    patterns,
+    commonPrefixes: Object.entries(prefixes)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5)
+      .map(([name, count]) => ({ name, count })),
+  };
+}
+
+/**
+ * Get PR template information
+ */
+function getPRTemplate(projectPath) {
+  const templates = [
+    ".github/pull_request_template.md",
+    ".github/PULL_REQUEST_TEMPLATE.md",
+    "PULL_REQUEST_TEMPLATE.md",
+  ];
+  
+  for (const template of templates) {
+    const templatePath = path.join(projectPath, template);
+    if (fs.existsSync(templatePath)) {
+      try {
+        const content = fs.readFileSync(templatePath, "utf-8");
+        
+        // Analyze template sections
+        const sections = [];
+        const lines = content.split("\n");
+        let currentSection = null;
+        
+        for (const line of lines) {
+          if (line.startsWith("##") || line.startsWith("###")) {
+            if (currentSection) {
+              sections.push(currentSection);
+            }
+            currentSection = {
+              title: line.replace(/^#+\s*/, ""),
+              required: line.includes("Required") || line.includes("MUST"),
+              content: [],
+            };
+          } else if (currentSection && line.trim()) {
+            currentSection.content.push(line);
+          }
+        }
+        
+        if (currentSection) {
+          sections.push(currentSection);
+        }
+        
+        return {
+          file: template,
+          sections,
+          hasRequiredSections: sections.some(s => s.required),
+          sectionCount: sections.length,
+        };
+      } catch {}
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Get git blame information for team patterns
+ */
+function getTeamPatterns(projectPath, fileLimit = 10) {
+  if (!isGitRepo(projectPath)) return null;
+  
+  // Get recent files
+  const output = execGit("ls-files -z", projectPath);
+  if (!output) return null;
+  
+  const files = output.split("\0")
+    .filter(f => f && (f.endsWith(".ts") || f.endsWith(".tsx") || f.endsWith(".js")))
+    .slice(0, fileLimit);
+  
+  const authorStats = {};
+  const patterns = {
+    commonImports: {},
+    commentStyles: {},
+    functionPatterns: {},
+  };
+  
+  for (const file of files) {
+    const blameOutput = execGit(`blame --line-porcelain "${file}"`, projectPath);
+    if (!blameOutput) continue;
+    
+    const lines = blameOutput.split("\n");
+    let currentAuthor = null;
+    
+    for (const line of lines) {
+      if (line.startsWith("author ")) {
+        currentAuthor = line.slice(7);
+        authorStats[currentAuthor] = (authorStats[currentAuthor] || 0) + 1;
+      } else if (line.startsWith("\t") && currentAuthor) {
+        const codeLine = line.slice(1);
+        
+        // Track patterns by author
+        if (!patterns.authorPatterns) patterns.authorPatterns = {};
+        if (!patterns.authorPatterns[currentAuthor]) {
+          patterns.authorPatterns[currentAuthor] = {
+            imports: [],
+            comments: [],
+            functions: [],
+          };
+        }
+        
+        // Import patterns
+        if (codeLine.includes("import ")) {
+          const importType = codeLine.includes(" from ") ? "named" : "default";
+          patterns.authorPatterns[currentAuthor].imports.push(importType);
+        }
+        
+        // Comment patterns
+        if (codeLine.includes("//")) {
+          patterns.authorPatterns[currentAuthor].comments.push(codeLine);
+        }
+        
+        // Function patterns
+        if (codeLine.includes("function ") || codeLine.includes("=>")) {
+          patterns.authorPatterns[currentAuthor].functions.push(codeLine);
+        }
+      }
+    }
+  }
+  
+  // Analyze top contributors
+  const topAuthors = Object.entries(authorStats)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 5)
+    .map(([name, lines]) => ({ name, lines }));
+  
+  return {
+    topAuthors,
+    totalAuthors: Object.keys(authorStats).length,
+    patterns,
+  };
+}
+
+/**
+ * Get complete git context
+ */
+function getGitContext(projectPath) {
+  if (!isGitRepo(projectPath)) {
+    return {
+      isRepo: false,
+      message: "Not a git repository",
+    };
+  }
+  
+  const commits = getRecentCommits(projectPath);
+  const branches = getBranchInfo(projectPath);
+  const prTemplate = getPRTemplate(projectPath);
+  const teamPatterns = getTeamPatterns(projectPath);
+  
+  return {
+    isRepo: true,
+    commits,
+    branches,
+    prTemplate,
+    teamPatterns,
+    conventions: {
+      commitMessages: commits?.analysis || null,
+      branchNaming: branches?.patterns || null,
+      hasPRTemplate: !!prTemplate,
+      teamSize: teamPatterns?.totalAuthors || 0,
+    },
+  };
+}
+
+module.exports = {
+  isGitRepo,
+  getGitContext,
+  getRecentCommits,
+  getBranchInfo,
+  getPRTemplate,
+  getTeamPatterns,
+};