vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/context/insights.js

@@ -0,0 +1,173 @@
+/**
+ * Chat History Insights Module
+ * Tracks context generation sessions and usage patterns
+ */
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const VIBECHECK_HOME = path.join(os.homedir(), ".vibecheck");
+const INSIGHTS_FILE = path.join(VIBECHECK_HOME, "insights.json");
+
+/**
+ * Initialize insights file
+ */
+function initializeInsights() {
+  if (!fs.existsSync(VIBECHECK_HOME)) {
+    fs.mkdirSync(VIBECHECK_HOME, { recursive: true });
+  }
+  
+  if (!fs.existsSync(INSIGHTS_FILE)) {
+    fs.writeFileSync(INSIGHTS_FILE, JSON.stringify({
+      sessions: [],
+      queries: [],
+      fileEdits: [],
+      totalSessions: 0,
+    }, null, 2));
+  }
+}
+
+/**
+ * Track chat/context usage insights
+ */
+function trackInsight(projectPath, action, data = {}) {
+  initializeInsights();
+  
+  let insights;
+  try {
+    insights = JSON.parse(fs.readFileSync(INSIGHTS_FILE, "utf-8"));
+  } catch {
+    insights = { sessions: [], queries: [], fileEdits: [], totalSessions: 0 };
+  }
+
+  const entry = {
+    timestamp: new Date().toISOString(),
+    project: path.basename(projectPath),
+    projectPath: projectPath,
+    action,
+    ...data,
+  };
+
+  switch (action) {
+    case "context_generated":
+      insights.sessions.push(entry);
+      insights.totalSessions++;
+      break;
+    case "file_edit":
+      insights.fileEdits.push(entry);
+      break;
+    case "query":
+      insights.queries.push(entry);
+      break;
+  }
+
+  // Keep last 500 entries per category
+  insights.sessions = insights.sessions.slice(-500);
+  insights.fileEdits = insights.fileEdits.slice(-500);
+  insights.queries = insights.queries.slice(-500);
+
+  fs.writeFileSync(INSIGHTS_FILE, JSON.stringify(insights, null, 2));
+  return insights;
+}
+
+/**
+ * Get most active hours from sessions
+ */
+function getMostActiveHours(sessions) {
+  const hours = {};
+  for (const session of sessions) {
+    const hour = new Date(session.timestamp).getHours();
+    hours[hour] = (hours[hour] || 0) + 1;
+  }
+  return Object.entries(hours)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 3)
+    .map(([hour]) => `${hour}:00`);
+}
+
+/**
+ * Get insights summary for dashboard
+ */
+function getInsightsSummary() {
+  initializeInsights();
+  
+  try {
+    const insights = JSON.parse(fs.readFileSync(INSIGHTS_FILE, "utf-8"));
+    const now = new Date();
+    const dayAgo = new Date(now - 24 * 60 * 60 * 1000);
+    const weekAgo = new Date(now - 7 * 24 * 60 * 60 * 1000);
+
+    return {
+      totalSessions: insights.totalSessions || 0,
+      sessionsToday: insights.sessions?.filter(s => new Date(s.timestamp) > dayAgo).length || 0,
+      sessionsThisWeek: insights.sessions?.filter(s => new Date(s.timestamp) > weekAgo).length || 0,
+      totalFileEdits: insights.fileEdits?.length || 0,
+      recentProjects: [...new Set(insights.sessions?.slice(-20).map(s => s.project))],
+      mostActiveHours: getMostActiveHours(insights.sessions || []),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get recent sessions
+ */
+function getRecentSessions(limit = 10) {
+  initializeInsights();
+  
+  try {
+    const insights = JSON.parse(fs.readFileSync(INSIGHTS_FILE, "utf-8"));
+    return insights.sessions?.slice(-limit).reverse() || [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get project activity
+ */
+function getProjectActivity(projectPath) {
+  initializeInsights();
+  
+  try {
+    const insights = JSON.parse(fs.readFileSync(INSIGHTS_FILE, "utf-8"));
+    const projectName = path.basename(projectPath);
+    
+    const sessions = insights.sessions?.filter(s => s.project === projectName) || [];
+    const fileEdits = insights.fileEdits?.filter(f => f.project === projectName) || [];
+    
+    return {
+      totalSessions: sessions.length,
+      lastSession: sessions[sessions.length - 1]?.timestamp || null,
+      totalFileEdits: fileEdits.length,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Clear all insights
+ */
+function clearInsights() {
+  const insights = {
+    sessions: [],
+    queries: [],
+    fileEdits: [],
+    totalSessions: 0,
+  };
+  fs.writeFileSync(INSIGHTS_FILE, JSON.stringify(insights, null, 2));
+}
+
+module.exports = {
+  INSIGHTS_FILE,
+  initializeInsights,
+  trackInsight,
+  getInsightsSummary,
+  getRecentSessions,
+  getProjectActivity,
+  getMostActiveHours,
+  clearInsights,
+};

package/bin/runners/context/mcp-server/generate-rules.js

@@ -0,0 +1,337 @@
+/**
+ * Generate thin rules files that point to MCP tools
+ * These are the "policy layer" - short files that tell agents what tools to call
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Generate Cursor MCP config
+ */
+function generateCursorMCPConfig(projectPath) {
+  return {
+    mcpServers: {
+      "vibecheck-context": {
+        command: "node",
+        args: [path.join(projectPath, ".vibecheck", "mcp-server", "index.js"), "serve"],
+        env: {}
+      }
+    }
+  };
+}
+
+/**
+ * Generate thin Cursor rules that point to MCP tools
+ */
+function generateCursorMCPRules(projectPath, analysis) {
+  const projectName = path.basename(projectPath);
+  
+  return `---
+description: Context Engine Integration - USE THESE TOOLS BEFORE MAKING CHANGES
+globs: ["**/*"]
+alwaysApply: true
+---
+
+# 🔧 Context Engine Tools (MCP)
+
+> This project has a Context Engine. ALWAYS use these tools before making changes.
+
+## MANDATORY WORKFLOW
+
+### Before Planning ANY Change:
+\`\`\`
+1. Call repo_map() → understand architecture
+2. Call risk_blast_radius(files) → assess impact
+\`\`\`
+
+### Before Using ANY Symbol:
+\`\`\`
+Call symbols_exists(name) → verify it exists
+If returns { exists: false } → DO NOT USE IT
+\`\`\`
+
+### Before Using ANY Package:
+\`\`\`
+Call versions_allowed(package) → verify installed
+If returns { allowed: false } → DO NOT SUGGEST IT
+\`\`\`
+
+### Before Claiming ANY Route Exists:
+\`\`\`
+Call routes_exists(method, path) → verify it exists
+If returns { exists: false } → DO NOT INVENT IT
+\`\`\`
+
+### When Creating New Code:
+\`\`\`
+Call patterns_get(type) → get verified pattern
+Available: api-route, component, hook
+\`\`\`
+
+### Before Touching Auth:
+\`\`\`
+Call security_auth_flow() → understand auth system
+Follow existing patterns exactly
+\`\`\`
+
+### After Making Changes:
+\`\`\`
+Call tests_required(files) → know what to test
+Call verify_changes(changes) → final check
+\`\`\`
+
+## Project Identity
+
+- **Name**: ${projectName}
+- **Framework**: ${analysis?.framework || "Unknown"}
+- **Language**: ${analysis?.language || "Unknown"}
+
+## HARD RULES
+
+1. ❌ **NEVER** invent symbols without calling \`symbols_exists\`
+2. ❌ **NEVER** suggest packages without calling \`versions_allowed\`
+3. ❌ **NEVER** claim routes exist without calling \`routes_exists\`
+4. ❌ **NEVER** touch auth without calling \`security_auth_flow\`
+5. ✅ **ALWAYS** call \`repo_map\` before planning changes
+6. ✅ **ALWAYS** call \`patterns_get\` when creating new code
+
+## If Tools Return "Not Found"
+
+When a tool says something doesn't exist:
+- Do NOT proceed as if it does
+- Do NOT invent alternatives
+- ASK the user for clarification or guidance
+
+---
+*Powered by vibecheck Context Engine*
+`;
+}
+
+/**
+ * Generate thin Windsurf rules
+ */
+function generateWindsurfMCPRules(projectPath, analysis) {
+  const projectName = path.basename(projectPath);
+  
+  return `---
+trigger: always
+description: Context Engine Integration for ${projectName}
+---
+
+# Context Engine Integration
+
+This project uses the vibecheck Context Engine. Query it before making changes.
+
+## Project Info
+- Framework: ${analysis?.framework || "Unknown"}
+- Language: ${analysis?.language || "Unknown"}
+- State: ${analysis?.antiHallucination?.stateManagement || "N/A"}
+
+## Available Tools (via MCP)
+
+| Tool | Use When |
+|------|----------|
+| \`repo_map()\` | Starting any task |
+| \`symbols_exists(name)\` | Before using any function/component |
+| \`versions_allowed(pkg)\` | Before suggesting packages |
+| \`routes_exists(method, path)\` | Before claiming API exists |
+| \`patterns_get(type)\` | When creating new code |
+| \`security_auth_flow()\` | Before touching auth |
+| \`tests_required(files)\` | After making changes |
+| \`risk_blast_radius(files)\` | Before risky changes |
+
+## Mandatory Checks
+
+1. **Before planning**: Call \`repo_map()\`
+2. **Before using symbols**: Call \`symbols_exists()\`
+3. **Before packages**: Call \`versions_allowed()\`
+4. **Before auth changes**: Call \`security_auth_flow()\`
+
+## If Tool Says "Not Found"
+
+- Do NOT proceed as if it exists
+- Do NOT invent alternatives  
+- ASK user for guidance
+`;
+}
+
+/**
+ * Generate thin Copilot instructions
+ */
+function generateCopilotMCPInstructions(projectPath, analysis) {
+  const projectName = path.basename(projectPath);
+  
+  return `# ${projectName} - AI Context Instructions
+
+## Project Stack
+- Framework: ${analysis?.framework || "Unknown"}
+- Language: ${analysis?.language || "Unknown"}
+- ORM: ${analysis?.antiHallucination?.ormType || "N/A"}
+- UI: ${analysis?.antiHallucination?.uiLibrary?.name || "N/A"}
+- State: ${analysis?.antiHallucination?.stateManagement || "N/A"}
+
+## Context Engine Available
+
+This project has a Context Engine with verified facts. Query the \`.vibecheck/truth-pack.json\` for:
+
+- **Symbols**: All exported functions, components, hooks
+- **Routes**: All API endpoints with file:line proof
+- **Versions**: All installed packages with exact versions
+- **Patterns**: Verified code patterns to follow
+- **Security**: Auth files, middleware, protected routes
+
+## Mandatory Rules
+
+### DO NOT:
+- Invent functions that aren't in the symbol index
+- Suggest packages not in package.json
+- Claim routes exist without proof
+- Bypass auth patterns
+
+### ALWAYS:
+- Check truth-pack.json before claiming something exists
+- Follow existing patterns from the codebase
+- Verify package versions before suggesting APIs
+- Reference file:line when citing code
+
+## Verification
+
+Before suggesting code:
+1. Verify symbols exist in truth-pack.json
+2. Verify packages are installed
+3. Check patterns for correct style
+4. Assess blast radius for risky files
+
+---
+*Generated by vibecheck Context Engine*
+`;
+}
+
+/**
+ * Generate Claude project context with MCP config
+ */
+function generateClaudeMCPContext(projectPath, analysis) {
+  const projectName = path.basename(projectPath);
+  
+  return `# ${projectName} - Project Context
+
+## Stack
+- **Framework**: ${analysis?.framework || "Unknown"}
+- **Language**: ${analysis?.language || "Unknown"}
+- **Database**: ${analysis?.antiHallucination?.ormType || "N/A"}
+- **UI Library**: ${analysis?.antiHallucination?.uiLibrary?.name || "N/A"}
+- **State Management**: ${analysis?.antiHallucination?.stateManagement || "N/A"}
+
+## Context Engine
+
+This project has a vibecheck Context Engine at \`.vibecheck/\`.
+
+### Truth Pack Location
+\`\`\`
+.vibecheck/truth-pack.json
+\`\`\`
+
+Contains verified:
+- Symbol index (what exists)
+- Route map (API endpoints)
+- Version truth (installed packages)
+- Security map (auth flow)
+- Golden patterns (verified code)
+- Risk map (critical files)
+
+## MCP Tools
+
+If MCP is configured, use these tools:
+
+| Tool | Purpose |
+|------|---------|
+| repo_map | Get architecture overview |
+| symbols_exists | Verify symbol exists |
+| versions_allowed | Verify package installed |
+| routes_exists | Verify route exists |
+| patterns_get | Get verified pattern |
+| security_auth_flow | Get auth info |
+| tests_required | Get test requirements |
+| risk_blast_radius | Assess change risk |
+
+## Rules
+
+1. **Verify before using** - Check truth-pack before claiming things exist
+2. **Follow patterns** - Use golden patterns for new code
+3. **Respect versions** - Only use installed package APIs
+4. **Check risk** - Assess blast radius for critical files
+`;
+}
+
+/**
+ * Copy MCP server to project
+ */
+function copyMCPServerToProject(projectPath) {
+  const vibecheckDir = path.join(projectPath, ".vibecheck", "mcp-server");
+  
+  if (!fs.existsSync(vibecheckDir)) {
+    fs.mkdirSync(vibecheckDir, { recursive: true });
+  }
+
+  // Copy the MCP server
+  const serverSource = path.join(__dirname, "index.js");
+  const serverDest = path.join(vibecheckDir, "index.js");
+  
+  if (fs.existsSync(serverSource)) {
+    fs.copyFileSync(serverSource, serverDest);
+  }
+
+  // Create package.json
+  const pkgContent = {
+    name: "vibecheck-context-engine",
+    version: "1.0.0",
+    main: "index.js",
+    scripts: {
+      "index": "node index.js index --path=../..",
+      "serve": "node index.js serve --http --path=../..",
+      "serve:mcp": "node index.js serve --path=../.."
+    }
+  };
+  
+  fs.writeFileSync(
+    path.join(vibecheckDir, "package.json"),
+    JSON.stringify(pkgContent, null, 2)
+  );
+
+  return vibecheckDir;
+}
+
+/**
+ * Generate all MCP-related files
+ */
+function generateMCPFiles(projectPath, analysis) {
+  const files = {};
+
+  // Cursor MCP config
+  files[".cursor/mcp.json"] = JSON.stringify(generateCursorMCPConfig(projectPath), null, 2);
+  
+  // Cursor thin rules
+  files[".cursor/rules/context-engine.mdc"] = generateCursorMCPRules(projectPath, analysis);
+  
+  // Windsurf thin rules
+  files[".windsurf/rules/context-engine.md"] = generateWindsurfMCPRules(projectPath, analysis);
+  
+  // Copilot instructions
+  files[".github/copilot-context.md"] = generateCopilotMCPInstructions(projectPath, analysis);
+  
+  // Claude context
+  files[".claude/project-context.md"] = generateClaudeMCPContext(projectPath, analysis);
+
+  return files;
+}
+
+module.exports = {
+  generateCursorMCPConfig,
+  generateCursorMCPRules,
+  generateWindsurfMCPRules,
+  generateCopilotMCPInstructions,
+  generateClaudeMCPContext,
+  copyMCPServerToProject,
+  generateMCPFiles,
+};