vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/context/multi-repo-federation.js

@@ -0,0 +1,404 @@
+/**
+ * Multi-Repo Context Federation Module
+ * Unified context across related repositories
+ */
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const VIBECHECK_HOME = path.join(os.homedir(), ".vibecheck");
+const FEDERATION_FILE = path.join(VIBECHECK_HOME, "repo-federation.json");
+
+/**
+ * Initialize federation config
+ */
+function initializeFederation() {
+  if (!fs.existsSync(VIBECHECK_HOME)) {
+    fs.mkdirSync(VIBECHECK_HOME, { recursive: true });
+  }
+  
+  if (!fs.existsSync(FEDERATION_FILE)) {
+    fs.writeFileSync(FEDERATION_FILE, JSON.stringify({
+      version: "1.0.0",
+      groups: {},
+      repositories: {},
+      sharedArtifacts: {},
+    }, null, 2));
+  }
+}
+
+/**
+ * Load federation config
+ */
+function loadFederation() {
+  initializeFederation();
+  try {
+    return JSON.parse(fs.readFileSync(FEDERATION_FILE, "utf-8"));
+  } catch {
+    return { groups: {}, repositories: {}, sharedArtifacts: {} };
+  }
+}
+
+/**
+ * Save federation config
+ */
+function saveFederation(config) {
+  initializeFederation();
+  fs.writeFileSync(FEDERATION_FILE, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Register repository in federation
+ */
+function registerRepository(repoPath, options = {}) {
+  const config = loadFederation();
+  const repoId = path.basename(repoPath);
+  
+  // Detect repo type and patterns
+  const packageJsonPath = path.join(repoPath, "package.json");
+  let repoInfo = {
+    id: repoId,
+    path: repoPath,
+    type: "unknown",
+    registered: new Date().toISOString(),
+    ...options,
+  };
+  
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      repoInfo.type = pkg.private ? "private" : "public";
+      repoInfo.name = pkg.name;
+      repoInfo.description = pkg.description;
+      repoInfo.dependencies = Object.keys(pkg.dependencies || {});
+      repoInfo.devDependencies = Object.keys(pkg.devDependencies || {});
+      
+      // Detect framework
+      if (pkg.dependencies?.next) repoInfo.framework = "Next.js";
+      else if (pkg.dependencies?.react) repoInfo.framework = "React";
+      else if (pkg.dependencies?.express) repoInfo.framework = "Express";
+      else if (pkg.dependencies?.vue) repoInfo.framework = "Vue";
+    } catch {}
+  }
+  
+  config.repositories[repoId] = repoInfo;
+  
+  // Auto-add to groups based on patterns
+  if (repoInfo.framework) {
+    const groupName = `${repoInfo.framework.toLowerCase()}-projects`;
+    if (!config.groups[groupName]) {
+      config.groups[groupName] = {
+        name: groupName,
+        description: `${repoInfo.framework} projects`,
+        repositories: [],
+      };
+    }
+    if (!config.groups[groupName].repositories.includes(repoId)) {
+      config.groups[groupName].repositories.push(repoId);
+    }
+  }
+  
+  saveFederation(config);
+  return repoInfo;
+}
+
+/**
+ * Create repository group
+ */
+function createGroup(name, description, repoIds = []) {
+  const config = loadFederation();
+  
+  config.groups[name] = {
+    name,
+    description,
+    repositories: repoIds,
+    created: new Date().toISOString(),
+  };
+  
+  saveFederation(config);
+}
+
+/**
+ * Get shared artifacts across repositories
+ */
+function getSharedArtifacts(groupName = null) {
+  const config = loadFederation();
+  const artifacts = {
+    components: new Map(),
+    hooks: new Map(),
+    utilities: new Map(),
+    types: new Map(),
+    patterns: new Map(),
+  };
+  
+  const repos = groupName 
+    ? config.groups[groupName]?.repositories || []
+    : Object.keys(config.repositories);
+  
+  for (const repoId of repos) {
+    const repo = config.repositories[repoId];
+    if (!repo) continue;
+    
+    // Load context from each repo
+    const contextFile = path.join(repo.path, ".vibecheck", "context.json");
+    if (fs.existsSync(contextFile)) {
+      try {
+        const context = JSON.parse(fs.readFileSync(contextFile, "utf-8"));
+        
+        // Collect components
+        if (context.structure?.components) {
+          for (const comp of context.structure.components) {
+            if (!artifacts.components.has(comp)) {
+              artifacts.components.set(comp, []);
+            }
+            artifacts.components.get(comp).push({
+              repo: repoId,
+              path: comp,
+              framework: context.project?.framework,
+            });
+          }
+        }
+        
+        // Collect hooks
+        if (context.patterns?.hooks) {
+          for (const hook of context.patterns.hooks) {
+            if (!artifacts.hooks.has(hook)) {
+              artifacts.hooks.set(hook, []);
+            }
+            artifacts.hooks.get(hook).push({
+              repo: repoId,
+              name: hook,
+            });
+          }
+        }
+        
+        // Collect patterns
+        if (context.patterns?.stateManagement) {
+          const pattern = context.patterns.stateManagement;
+          if (!artifacts.patterns.has(pattern)) {
+            artifacts.patterns.set(pattern, []);
+          }
+          artifacts.patterns.get(pattern).push(repoId);
+        }
+        
+        // Collect types
+        if (context.types?.interfaces) {
+          for (const type of context.types.interfaces) {
+            if (!artifacts.types.has(type)) {
+              artifacts.types.set(type, []);
+            }
+            artifacts.types.get(type).push({
+              repo: repoId,
+              interface: type,
+            });
+          }
+        }
+      } catch {}
+    }
+  }
+  
+  // Convert Maps to arrays and filter for shared items
+  const shared = {};
+  for (const [key, map] of Object.entries(artifacts)) {
+    shared[key] = Array.from(map.entries())
+      .filter(([_, items]) => items.length > 1) // Only keep items shared across repos
+      .map(([name, items]) => ({
+        name,
+        repositories: items,
+        count: items.length,
+      }))
+      .sort((a, b) => b.count - a.count);
+  }
+  
+  return shared;
+}
+
+/**
+ * Generate federated context
+ */
+function generateFederatedContext(groupName = null, options = {}) {
+  const { maxTokens = 8000, includePatterns = true } = options;
+  const config = loadFederation();
+  
+  const repos = groupName 
+    ? config.groups[groupName]?.repositories || []
+    : Object.keys(config.repositories);
+  
+  const federated = {
+    version: "1.0.0",
+    generated: new Date().toISOString(),
+    group: groupName,
+    repositories: repos.map(id => ({
+      id,
+      ...config.repositories[id],
+    })),
+    sharedArtifacts: getSharedArtifacts(groupName),
+    context: {
+      components: [],
+      hooks: [],
+      patterns: [],
+      types: [],
+    },
+    stats: {
+      totalRepos: repos.length,
+      sharedComponents: 0,
+      sharedHooks: 0,
+      sharedPatterns: 0,
+    },
+  };
+  
+  // Build unified context
+  let totalTokens = 0;
+  
+  // Add shared components
+  for (const comp of federated.sharedArtifacts.components.slice(0, 20)) {
+    if (totalTokens > maxTokens * 0.4) break;
+    
+    federated.context.components.push({
+      name: comp.name,
+      usage: comp.repositories,
+      example: comp.repositories[0],
+    });
+    federated.stats.sharedComponents++;
+  }
+  
+  // Add shared hooks
+  for (const hook of federated.sharedArtifacts.hooks.slice(0, 15)) {
+    if (totalTokens > maxTokens * 0.6) break;
+    
+    federated.context.hooks.push({
+      name: hook.name,
+      repos: hook.repositories,
+    });
+    federated.stats.sharedHooks++;
+  }
+  
+  // Add shared patterns
+  for (const pattern of federated.sharedArtifacts.patterns) {
+    if (totalTokens > maxTokens * 0.8) break;
+    
+    federated.context.patterns.push({
+      name: pattern.name,
+      repos: pattern.repositories,
+    });
+    federated.stats.sharedPatterns++;
+  }
+  
+  return federated;
+}
+
+/**
+ * Find related repositories
+ */
+function findRelatedRepositories(repoPath, limit = 5) {
+  const config = loadFederation();
+  const repoId = path.basename(repoPath);
+  const repo = config.repositories[repoId];
+  
+  if (!repo) return [];
+  
+  const related = [];
+  
+  // Find repos with similar dependencies
+  for (const [id, otherRepo] of Object.entries(config.repositories)) {
+    if (id === repoId) continue;
+    
+    let similarity = 0;
+    
+    // Same framework
+    if (repo.framework === otherRepo.framework) {
+      similarity += 3;
+    }
+    
+    // Shared dependencies
+    const sharedDeps = (repo.dependencies || []).filter(d => 
+      (otherRepo.dependencies || []).includes(d)
+    ).length;
+    similarity += sharedDeps * 0.5;
+    
+    // Same type (private/public)
+    if (repo.type === otherRepo.type) {
+      similarity += 1;
+    }
+    
+    if (similarity > 0) {
+      related.push({
+        id,
+        ...otherRepo,
+        similarity,
+      });
+    }
+  }
+  
+  return related
+    .sort((a, b) => b.similarity - a.similarity)
+    .slice(0, limit);
+}
+
+/**
+ * Sync federation with remote
+ */
+function syncFederation(remoteUrl) {
+  // In a real implementation, this would sync with a remote service
+  // For now, just mark as synced
+  const config = loadFederation();
+  config.lastSync = new Date().toISOString();
+  config.remoteUrl = remoteUrl;
+  saveFederation(config);
+}
+
+/**
+ * Generate federation report
+ */
+function generateFederationReport(federated) {
+  let report = `# Multi-Repository Federation Report\n\n`;
+  report += `Generated: ${new Date(federated.generated).toLocaleString()}\n`;
+  report += `Group: ${federated.group || "All"}\n`;
+  report += `Repositories: ${federated.stats.totalRepos}\n\n`;
+  
+  // Repositories
+  report += `## Repositories\n\n`;
+  for (const repo of federated.repositories) {
+    report += `- **${repo.name || repo.id}** (${repo.framework || "Unknown"})\n`;
+    report += `  - Path: ${repo.path}\n`;
+    report += `  - Dependencies: ${repo.dependencies?.length || 0}\n`;
+  }
+  
+  // Shared artifacts
+  report += `\n## Shared Artifacts\n\n`;
+  
+  if (federated.sharedArtifacts.components.length > 0) {
+    report += `### Components (${federated.stats.sharedComponents})\n\n`;
+    for (const comp of federated.sharedArtifacts.components.slice(0, 10)) {
+      report += `- **${comp.name}** - Used in ${comp.count} repos\n`;
+    }
+  }
+  
+  if (federated.sharedArtifacts.hooks.length > 0) {
+    report += `\n### Hooks (${federated.stats.sharedHooks})\n\n`;
+    for (const hook of federated.sharedArtifacts.hooks.slice(0, 10)) {
+      report += `- **${hook.name}** - Used in ${hook.count} repos\n`;
+    }
+  }
+  
+  if (federated.sharedArtifacts.patterns.length > 0) {
+    report += `\n### Patterns (${federated.stats.sharedPatterns})\n\n`;
+    for (const pattern of federated.sharedArtifacts.patterns) {
+      report += `- **${pattern.name}** - Used in ${pattern.count} repos\n`;
+    }
+  }
+  
+  return report;
+}
+
+module.exports = {
+  registerRepository,
+  createGroup,
+  getSharedArtifacts,
+  generateFederatedContext,
+  findRelatedRepositories,
+  syncFederation,
+  generateFederationReport,
+  loadFederation,
+};

package/bin/runners/context/patterns.js

@@ -0,0 +1,253 @@
+/**
+ * Pattern Detection Module
+ * Detects code patterns, hooks, state management, styling, and anti-patterns
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Find files recursively (local helper)
+ */
+function findFiles(dir, extensions, maxDepth = 5, currentDepth = 0) {
+  if (currentDepth >= maxDepth || !fs.existsSync(dir)) return [];
+  
+  const files = [];
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        files.push(...findFiles(fullPath, extensions, maxDepth, currentDepth + 1));
+      } else if (entry.isFile() && extensions.some(ext => entry.name.endsWith(ext))) {
+        files.push(fullPath);
+      }
+    }
+  } catch {}
+  return files;
+}
+
+/**
+ * Extract a function example from code
+ */
+function extractFunctionExample(content, functionName) {
+  const regex = new RegExp(`(export\\s+)?(function|const)\\s+${functionName}[^{]*\\{`, 'g');
+  const match = regex.exec(content);
+  if (!match) return null;
+  
+  const startIndex = match.index;
+  let braceCount = 0;
+  let endIndex = startIndex;
+  let started = false;
+  
+  for (let i = startIndex; i < content.length && i < startIndex + 500; i++) {
+    if (content[i] === '{') {
+      braceCount++;
+      started = true;
+    } else if (content[i] === '}') {
+      braceCount--;
+    }
+    if (started && braceCount === 0) {
+      endIndex = i + 1;
+      break;
+    }
+  }
+  
+  const example = content.slice(startIndex, endIndex);
+  return example.length < 400 ? example : example.slice(0, 400) + '\n  // ...';
+}
+
+/**
+ * Detect anti-patterns in code
+ */
+function detectAntiPatterns(content, filePath, antiPatterns) {
+  // Console.log in production code
+  if (!filePath.includes('.test.') && !filePath.includes('.spec.') && !filePath.includes('__tests__')) {
+    if (/console\.(log|error|warn)\(/.test(content)) {
+      const existing = antiPatterns.find(a => a.type === 'console-log');
+      if (!existing) {
+        antiPatterns.push({
+          type: 'console-log',
+          severity: 'warning',
+          message: 'Console statements found in production code',
+          suggestion: 'Use a proper logger or remove before production',
+        });
+      }
+    }
+  }
+
+  // Any type usage
+  if (/:\s*any\b/.test(content)) {
+    const existing = antiPatterns.find(a => a.type === 'any-type');
+    if (!existing) {
+      antiPatterns.push({
+        type: 'any-type',
+        severity: 'warning',
+        message: 'Usage of `any` type detected',
+        suggestion: 'Use proper TypeScript types or `unknown`',
+      });
+    }
+  }
+
+  // Hardcoded secrets
+  if (/(api[_-]?key|password|secret|token)\s*[:=]\s*['"][^'"]+['"]/i.test(content)) {
+    const existing = antiPatterns.find(a => a.type === 'hardcoded-secret');
+    if (!existing) {
+      antiPatterns.push({
+        type: 'hardcoded-secret',
+        severity: 'error',
+        message: 'Potential hardcoded secrets detected',
+        suggestion: 'Use environment variables for sensitive data',
+      });
+    }
+  }
+
+  // Mock data patterns
+  if (/(jsonplaceholder|reqres\.in|mockapi|faker|fake[A-Z])/i.test(content)) {
+    const existing = antiPatterns.find(a => a.type === 'mock-data');
+    if (!existing) {
+      antiPatterns.push({
+        type: 'mock-data',
+        severity: 'warning',
+        message: 'Mock data or fake APIs detected',
+        suggestion: 'Replace with real API endpoints before production',
+      });
+    }
+  }
+
+  // TODO/FIXME comments
+  if (/\/\/\s*(TODO|FIXME|HACK|XXX):/i.test(content)) {
+    const existing = antiPatterns.find(a => a.type === 'todo-comments');
+    if (!existing) {
+      antiPatterns.push({
+        type: 'todo-comments',
+        severity: 'info',
+        message: 'TODO/FIXME comments found',
+        suggestion: 'Address these items before shipping',
+      });
+    }
+  }
+}
+
+/**
+ * Deep pattern detection - analyzes actual code patterns
+ */
+function detectPatterns(projectPath) {
+  const patterns = {
+    hooks: [],
+    stateManagement: null,
+    styling: [],
+    testing: [],
+    dataFetching: [],
+    validation: null,
+    authentication: null,
+    codeExamples: {},
+    antiPatterns: [],
+  };
+
+  const srcFiles = findFiles(projectPath, [".ts", ".tsx", ".js", ".jsx"], 6);
+  
+  for (const file of srcFiles.slice(0, 100)) {
+    try {
+      const content = fs.readFileSync(file, "utf-8");
+      const relativePath = path.relative(projectPath, file);
+      
+      // Detect custom hooks
+      const hookMatches = content.match(/export\s+(function|const)\s+(use[A-Z]\w+)/g);
+      if (hookMatches) {
+        hookMatches.forEach(match => {
+          const hookName = match.match(/use[A-Z]\w+/)?.[0];
+          if (hookName && !patterns.hooks.includes(hookName)) {
+            patterns.hooks.push(hookName);
+            if (!patterns.codeExamples.hooks) {
+              const hookExample = extractFunctionExample(content, hookName);
+              if (hookExample) {
+                patterns.codeExamples.hooks = { name: hookName, code: hookExample, file: relativePath };
+              }
+            }
+          }
+        });
+      }
+
+      // Detect state management
+      if (content.includes("zustand") || content.includes("create(")) {
+        patterns.stateManagement = "Zustand";
+      } else if (content.includes("@reduxjs/toolkit") || content.includes("createSlice")) {
+        patterns.stateManagement = "Redux Toolkit";
+      } else if (content.includes("recoil") || content.includes("atom(")) {
+        patterns.stateManagement = "Recoil";
+      } else if (content.includes("jotai")) {
+        patterns.stateManagement = "Jotai";
+      } else if (content.includes("createContext") && !patterns.stateManagement) {
+        patterns.stateManagement = "React Context";
+      }
+
+      // Detect styling patterns
+      if (content.includes("styled-components") || content.includes("styled.")) {
+        if (!patterns.styling.includes("Styled Components")) patterns.styling.push("Styled Components");
+      }
+      if (content.includes("@emotion") || content.includes("css``")) {
+        if (!patterns.styling.includes("Emotion")) patterns.styling.push("Emotion");
+      }
+      if (content.includes("className=") && content.includes("tailwind")) {
+        if (!patterns.styling.includes("Tailwind CSS")) patterns.styling.push("Tailwind CSS");
+      }
+      if (content.includes(".module.css") || content.includes(".module.scss")) {
+        if (!patterns.styling.includes("CSS Modules")) patterns.styling.push("CSS Modules");
+      }
+
+      // Detect data fetching patterns
+      if (content.includes("@tanstack/react-query") || content.includes("useQuery")) {
+        if (!patterns.dataFetching.includes("TanStack Query")) patterns.dataFetching.push("TanStack Query");
+      }
+      if (content.includes("useSWR") || content.includes("swr")) {
+        if (!patterns.dataFetching.includes("SWR")) patterns.dataFetching.push("SWR");
+      }
+      if (content.includes("trpc") || content.includes("createTRPCReact")) {
+        if (!patterns.dataFetching.includes("tRPC")) patterns.dataFetching.push("tRPC");
+      }
+
+      // Detect validation
+      if (content.includes("zod") || content.includes("z.object")) {
+        patterns.validation = "Zod";
+      } else if (content.includes("yup") && !patterns.validation) {
+        patterns.validation = "Yup";
+      }
+
+      // Detect authentication
+      if (content.includes("next-auth") || content.includes("NextAuth")) {
+        patterns.authentication = "NextAuth.js";
+      } else if (content.includes("clerk") || content.includes("@clerk")) {
+        patterns.authentication = "Clerk";
+      } else if (content.includes("supabase") && content.includes("auth")) {
+        patterns.authentication = "Supabase Auth";
+      }
+
+      // Detect testing patterns
+      if (content.includes("@testing-library") || content.includes("render(")) {
+        if (!patterns.testing.includes("React Testing Library")) patterns.testing.push("React Testing Library");
+      }
+      if (content.includes("vitest") || content.includes("vi.mock")) {
+        if (!patterns.testing.includes("Vitest")) patterns.testing.push("Vitest");
+      }
+      if (content.includes("jest") || content.includes("describe(")) {
+        if (!patterns.testing.includes("Jest")) patterns.testing.push("Jest");
+      }
+      if (content.includes("playwright") || content.includes("@playwright")) {
+        if (!patterns.testing.includes("Playwright")) patterns.testing.push("Playwright");
+      }
+
+      // Detect anti-patterns
+      detectAntiPatterns(content, relativePath, patterns.antiPatterns);
+      
+    } catch {}
+  }
+
+  return patterns;
+}
+
+module.exports = {
+  detectPatterns,
+  detectAntiPatterns,
+  extractFunctionExample,
+};