vibecheck-ai 2.0.1 → 5.0.0

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,304 @@
+/**
+ * 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 {
+    // Prepend 'git' if not already present (Windows compatibility)
+    const gitCommand = command.startsWith('git ') ? command : `git ${command}`;
+    return execSync(gitCommand, { 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,
+};