vibecheck-ai 2.0.1 → 5.0.0

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

@@ -0,0 +1,342 @@
+/**
+ * Context Diff Module
+ * Tracks changes in context between generations
+ */
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+/**
+ * Generate hash for context snapshot
+ */
+function generateContextHash(context) {
+  const content = JSON.stringify(context, null, 2);
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+/**
+ * Save context snapshot
+ */
+function saveSnapshot(projectPath, context) {
+  const vibecheckDir = path.join(projectPath, ".vibecheck");
+  if (!fs.existsSync(vibecheckDir)) {
+    fs.mkdirSync(vibecheckDir, { recursive: true });
+  }
+  
+  const snapshot = {
+    timestamp: new Date().toISOString(),
+    hash: generateContextHash(context),
+    context: {
+      version: context.version,
+      project: context.project,
+      techStack: context.techStack,
+      structure: {
+        directories: context.structure?.directories || [],
+        componentsCount: context.structure?.components?.length || 0,
+        apiRoutesCount: context.structure?.apiRoutes?.length || 0,
+      },
+      patterns: {
+        hooks: context.patterns?.hooks || [],
+        stateManagement: context.patterns?.stateManagement,
+        validation: context.patterns?.validation,
+      },
+      monorepo: context.monorepo,
+    },
+  };
+  
+  const snapshotFile = path.join(vibecheckDir, "context-snapshot.json");
+  fs.writeFileSync(snapshotFile, JSON.stringify(snapshot, null, 2));
+  
+  return snapshot;
+}
+
+/**
+ * Load previous snapshot
+ */
+function loadSnapshot(projectPath) {
+  const snapshotFile = path.join(projectPath, ".vibecheck", "context-snapshot.json");
+  
+  if (!fs.existsSync(snapshotFile)) {
+    return null;
+  }
+  
+  try {
+    return JSON.parse(fs.readFileSync(snapshotFile, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Generate diff between contexts
+ */
+function generateContextDiff(previous, current) {
+  if (!previous) {
+    return {
+      isFirstRun: true,
+      changes: {
+        added: [],
+        removed: [],
+        modified: [],
+      },
+    };
+  }
+  
+  const diff = {
+    timestamp: new Date().toISOString(),
+    previousTimestamp: previous.timestamp,
+    changes: {
+      added: [],
+      removed: [],
+      modified: [],
+    },
+    summary: {
+      totalChanges: 0,
+      breakingChanges: 0,
+      additions: 0,
+      removals: 0,
+    },
+  };
+  
+  // Compare tech stack
+  if (previous.context.techStack && current.techStack) {
+    for (const [key, value] of Object.entries(current.techStack)) {
+      if (previous.context.techStack[key] !== value) {
+        diff.changes.modified.push({
+          type: "techStack",
+          field: key,
+          from: previous.context.techStack[key],
+          to: value,
+        });
+        diff.summary.totalChanges++;
+      }
+    }
+  }
+  
+  // Compare directories
+  const prevDirs = new Set(previous.context.structure?.directories || []);
+  const currDirs = new Set(current.structure?.directories || []);
+  
+  for (const dir of currDirs) {
+    if (!prevDirs.has(dir)) {
+      diff.changes.added.push({
+        type: "directory",
+        name: dir,
+      });
+      diff.summary.additions++;
+      diff.summary.totalChanges++;
+    }
+  }
+  
+  for (const dir of prevDirs) {
+    if (!currDirs.has(dir)) {
+      diff.changes.removed.push({
+        type: "directory",
+        name: dir,
+      });
+      diff.summary.removals++;
+      diff.summary.totalChanges++;
+    }
+  }
+  
+  // Compare components
+  const prevComponents = new Set(previous.context.structure?.components || []);
+  const currComponents = new Set(current.structure?.components || []);
+  
+  for (const comp of currComponents) {
+    if (!prevComponents.has(comp)) {
+      diff.changes.added.push({
+        type: "component",
+        name: comp,
+      });
+      diff.summary.additions++;
+      diff.summary.totalChanges++;
+    }
+  }
+  
+  for (const comp of prevComponents) {
+    if (!currComponents.has(comp)) {
+      diff.changes.removed.push({
+        type: "component",
+        name: comp,
+      });
+      diff.summary.removals++;
+      diff.summary.totalChanges++;
+    }
+  }
+  
+  // Compare API routes
+  const prevRoutes = new Set(previous.context.structure?.apiRoutes || []);
+  const currRoutes = new Set(current.structure?.apiRoutes || []);
+  
+  for (const route of currRoutes) {
+    if (!prevRoutes.has(route)) {
+      diff.changes.added.push({
+        type: "apiRoute",
+        name: route,
+      });
+      diff.summary.additions++;
+      diff.summary.totalChanges++;
+    }
+  }
+  
+  for (const route of prevRoutes) {
+    if (!currRoutes.has(route)) {
+      diff.changes.removed.push({
+        type: "apiRoute",
+        name: route,
+      });
+      diff.summary.removals++;
+      diff.summary.totalChanges++;
+    }
+  }
+  
+  // Compare patterns
+  const prevHooks = new Set(previous.context.patterns?.hooks || []);
+  const currHooks = new Set(current.patterns?.hooks || []);
+  
+  for (const hook of currHooks) {
+    if (!prevHooks.has(hook)) {
+      diff.changes.added.push({
+        type: "hook",
+        name: hook,
+      });
+      diff.summary.additions++;
+      diff.summary.totalChanges++;
+    }
+  }
+  
+  // Check for breaking changes
+  if (previous.context.patterns?.stateManagement !== current.patterns?.stateManagement) {
+    diff.changes.modified.push({
+      type: "breaking",
+      field: "stateManagement",
+      from: previous.context.patterns?.stateManagement,
+      to: current.patterns?.stateManagement,
+    });
+    diff.summary.breakingChanges++;
+    diff.summary.totalChanges++;
+  }
+  
+  if (previous.context.patterns?.validation !== current.patterns?.validation) {
+    diff.changes.modified.push({
+      type: "breaking",
+      field: "validation",
+      from: previous.context.patterns?.validation,
+      to: current.patterns?.validation,
+    });
+    diff.summary.breakingChanges++;
+    diff.summary.totalChanges++;
+  }
+  
+  return diff;
+}
+
+/**
+ * Generate diff report
+ */
+function generateDiffReport(diff) {
+  if (diff.isFirstRun) {
+    return `
+# First Context Generation
+
+This is the first time context has been generated for this project.
+`;
+  }
+  
+  let report = `# Context Changes Report
+Generated: ${new Date(diff.timestamp).toLocaleString()}
+Since: ${new Date(diff.previousTimestamp).toLocaleString()}
+
+## Summary
+- Total Changes: ${diff.summary.totalChanges}
+- Additions: ${diff.summary.additions}
+- Removals: ${diff.summary.removals}
+- Breaking Changes: ${diff.summary.breakingChanges}
+
+`;
+  
+  if (diff.changes.added.length > 0) {
+    report += "## Added\n\n";
+    for (const change of diff.changes.added) {
+      const icon = {
+        directory: "📁",
+        component: "🧩",
+        apiRoute: "🔌",
+        hook: "🪝",
+      }[change.type] || "➕";
+      
+      report += `- ${icon} **${change.type}**: ${change.name}\n`;
+    }
+    report += "\n";
+  }
+  
+  if (diff.changes.removed.length > 0) {
+    report += "## Removed\n\n";
+    for (const change of diff.changes.removed) {
+      const icon = {
+        directory: "📁",
+        component: "🧩",
+        apiRoute: "🔌",
+        hook: "🪝",
+      }[change.type] || "➖";
+      
+      report += `- ${icon} **${change.type}**: ${change.name}\n`;
+    }
+    report += "\n";
+  }
+  
+  if (diff.changes.modified.length > 0) {
+    report += "## Modified\n\n";
+    for (const change of diff.changes.modified) {
+      const icon = change.type === "breaking" ? "⚠️" : "🔄";
+      report += `- ${icon} **${change.field}**: \`${change.from}\` → \`${change.to}\`\n`;
+    }
+    report += "\n";
+  }
+  
+  if (diff.summary.breakingChanges > 0) {
+    report += "## ⚠️ Breaking Changes\n\n";
+    report += "Breaking changes detected. Review AI rules files to ensure compatibility.\n\n";
+  }
+  
+  return report;
+}
+
+/**
+ * Save diff report
+ */
+function saveDiffReport(projectPath, diff) {
+  const vibecheckDir = path.join(projectPath, ".vibecheck");
+  if (!fs.existsSync(vibecheckDir)) {
+    fs.mkdirSync(vibecheckDir, { recursive: true });
+  }
+  
+  const report = generateDiffReport(diff);
+  const reportFile = path.join(vibecheckDir, "context-diff.md");
+  
+  fs.writeFileSync(reportFile, report);
+  
+  return reportFile;
+}
+
+/**
+ * Check if context needs regeneration
+ */
+function needsRegeneration(projectPath, currentContext) {
+  const previous = loadSnapshot(projectPath);
+  if (!previous) return true;
+  
+  const currentHash = generateContextHash(currentContext);
+  return previous.hash !== currentHash;
+}
+
+module.exports = {
+  saveSnapshot,
+  loadSnapshot,
+  generateContextDiff,
+  generateDiffReport,
+  saveDiffReport,
+  needsRegeneration,
+};

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

@@ -0,0 +1,291 @@
+/**
+ * Smart Context Pruning Module
+ * Reduces context to most relevant subset based on current file/task
+ */
+
+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;
+}
+
+/**
+ * Calculate relevance score for a file based on context
+ */
+function calculateRelevanceScore(filePath, context, analysis) {
+  let score = 0;
+  const relativePath = path.relative(process.cwd(), filePath).replace(/\\/g, "/");
+  
+  // Base score for all files
+  score += 1;
+  
+  // Boost for same directory
+  if (context.currentFile) {
+    const currentDir = path.dirname(context.currentFile);
+    const fileDir = path.dirname(relativePath);
+    if (currentDir === fileDir) score += 5;
+  }
+  
+  // Boost for shared directory levels
+  if (context.currentFile) {
+    const currentParts = context.currentFile.split("/");
+    const fileParts = relativePath.split("/");
+    const sharedLevels = Math.min(
+      currentParts.length - 1,
+      fileParts.length - 1
+    );
+    for (let i = 0; i < sharedLevels; i++) {
+      if (currentParts[i] === fileParts[i]) {
+        score += 2;
+      } else {
+        break;
+      }
+    }
+  }
+  
+  // Boost for commonly imported files
+  if (analysis.imports?.internalAliases) {
+    for (const alias of analysis.imports.internalAliases) {
+      if (relativePath.startsWith(alias.replace("@", "src/"))) {
+        score += 3;
+      }
+    }
+  }
+  
+  // Boost based on file type
+  const ext = path.extname(relativePath);
+  const baseName = path.basename(relativePath, ext);
+  
+  // Components are highly relevant
+  if (relativePath.includes("/components/") && /^[A-Z]/.test(baseName)) {
+    score += 4;
+  }
+  
+  // Hooks are moderately relevant
+  if (relativePath.includes("/hooks/") || baseName.startsWith("use")) {
+    score += 3;
+  }
+  
+  // API routes for API-related tasks
+  if (context.task === "api" && relativePath.includes("/api/")) {
+    score += 5;
+  }
+  
+  // Utils for utility tasks
+  if (context.task === "utility" && (relativePath.includes("/utils/") || relativePath.includes("/lib/"))) {
+    score += 4;
+  }
+  
+  // Boost for files with many imports (likely core files)
+  const fileStats = analysis.stats?.byExtension || {};
+  if (fileStats[ext]) {
+    score += Math.min(2, fileStats[ext] / 10);
+  }
+  
+  // Boost for recently modified files (if git info available)
+  if (context.recentFiles && context.recentFiles.includes(relativePath)) {
+    score += 3;
+  }
+  
+  // Boost for files mentioned in custom hooks
+  if (analysis.patterns?.hooks?.includes(baseName)) {
+    score += 2;
+  }
+  
+  return score;
+}
+
+/**
+ * Prune context to most relevant files
+ */
+function pruneContext(analysis, context = {}) {
+  const {
+    maxTokens = 8000,
+    currentFile = "",
+    task = "general",
+    includeTypes = ["components", "hooks", "utils", "api"],
+    excludePatterns = ["*.test.*", "*.spec.*", "node_modules"],
+  } = context;
+  
+  // Get all relevant files
+  const allFiles = findFiles(process.cwd(), [".ts", ".tsx", ".js", ".jsx"], 5);
+  
+  // Filter by type and exclude patterns
+  const filteredFiles = allFiles.filter(file => {
+    const relativePath = path.relative(process.cwd(), file).replace(/\\/g, "/");
+    
+    // Check exclude patterns
+    for (const pattern of excludePatterns) {
+      if (relativePath.includes(pattern.replace("*", ""))) {
+        return false;
+      }
+    }
+    
+    // Check include types
+    const isInComponents = relativePath.includes("/components/");
+    const isInHooks = relativePath.includes("/hooks/") || path.basename(file).startsWith("use");
+    const isInUtils = relativePath.includes("/utils/") || relativePath.includes("/lib/");
+    const isInApi = relativePath.includes("/api/") || relativePath.includes("/routes/");
+    
+    return (
+      (includeTypes.includes("components") && isInComponents) ||
+      (includeTypes.includes("hooks") && isInHooks) ||
+      (includeTypes.includes("utils") && isInUtils) ||
+      (includeTypes.includes("api") && isInApi) ||
+      !includeTypes.length
+    );
+  });
+  
+  // Score and rank files
+  const scoredFiles = filteredFiles.map(file => ({
+    path: file,
+    relativePath: path.relative(process.cwd(), file).replace(/\\/g, "/"),
+    score: calculateRelevanceScore(file, context, analysis),
+  }));
+  
+  // Sort by score (descending)
+  scoredFiles.sort((a, b) => b.score - a.score);
+  
+  // Estimate token usage (rough estimate: ~4 tokens per character)
+  let totalTokens = 0;
+  const selectedFiles = [];
+  
+  for (const file of scoredFiles) {
+    try {
+      const content = fs.readFileSync(file.path, "utf-8");
+      const fileTokens = content.length / 4;
+      
+      if (totalTokens + fileTokens <= maxTokens) {
+        selectedFiles.push({
+          ...file,
+          content,
+          tokens: Math.round(fileTokens),
+        });
+        totalTokens += fileTokens;
+      } else {
+        // Try to include partial content for important files
+        if (file.score > 5) {
+          const remainingTokens = maxTokens - totalTokens;
+          const charsToFit = remainingTokens * 4;
+          const partialContent = content.slice(0, charsToFit) + "\n... [truncated]";
+          
+          selectedFiles.push({
+            ...file,
+            content: partialContent,
+            tokens: Math.round(partialContent.length / 4),
+            truncated: true,
+          });
+          totalTokens += partialContent.length / 4;
+        }
+        break;
+      }
+    } catch {}
+  }
+  
+  return {
+    files: selectedFiles,
+    totalTokens: Math.round(totalTokens),
+    maxTokens,
+    includedCount: selectedFiles.length,
+    totalCount: filteredFiles.length,
+    pruned: filteredFiles.length - selectedFiles.length,
+  };
+}
+
+/**
+ * Generate pruned context JSON for MCP
+ */
+function generatePrunedContext(analysis, context = {}) {
+  const pruned = pruneContext(analysis, context);
+  
+  return {
+    version: "3.0.0-pruned",
+    generatedAt: new Date().toISOString(),
+    context: {
+      currentFile: context.currentFile || "",
+      task: context.task || "general",
+      maxTokens: context.maxTokens || 8000,
+    },
+    summary: {
+      totalFiles: pruned.totalCount,
+      includedFiles: pruned.includedCount,
+      prunedFiles: pruned.pruned,
+      estimatedTokens: pruned.totalTokens,
+    },
+    files: pruned.files.map(f => ({
+      path: f.relativePath,
+      score: f.score,
+      tokens: f.tokens,
+      truncated: f.truncated || false,
+      content: f.content,
+    })),
+  };
+}
+
+/**
+ * Get context for specific file
+ */
+function getContextForFile(filePath, analysis) {
+  const relativePath = path.relative(process.cwd(), filePath).replace(/\\/g, "/");
+  
+  // Extract imports from current file
+  let imports = [];
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const importMatches = content.match(/import\s+.*?\s+from\s+['"]([^'"]+)['"]/g) || [];
+    
+    for (const match of importMatches) {
+      const source = match.match(/from\s+['"]([^'"]+)['"]/)?.[1];
+      if (source && source.startsWith(".")) {
+        // Resolve relative import
+        const fromDir = path.dirname(relativePath);
+        const resolvedPath = path.resolve(process.cwd(), fromDir, source);
+        imports.push(path.relative(process.cwd(), resolvedPath).replace(/\\/g, "/"));
+      }
+    }
+  } catch {}
+  
+  // Prune with focus on imported files
+  const context = generatePrunedContext(analysis, {
+    currentFile: relativePath,
+    maxTokens: 6000,
+    task: "file-specific",
+  });
+  
+  // Boost imported files in the results
+  for (const file of context.files) {
+    if (imports.includes(file.path)) {
+      file.score += 10;
+    }
+  }
+  
+  // Re-sort
+  context.files.sort((a, b) => b.score - a.score);
+  
+  return context;
+}
+
+module.exports = {
+  pruneContext,
+  generatePrunedContext,
+  getContextForFile,
+  calculateRelevanceScore,
+};