@vibecheckai/cli 3.0.2 → 3.0.3

package/bin/runners/context/mcp-server/package.json

@@ -1,24 +0,0 @@
-{
-  "name": "@vibecheck/context-engine",
-  "version": "1.0.0",
-  "description": "MCP Context Engine - Verified repo facts as tool calls for AI agents",
-  "main": "index.js",
-  "bin": {
-    "vibecheck-context": "./index.js"
-  },
-  "scripts": {
-    "index": "node index.js index",
-    "serve": "node index.js serve --http",
-    "serve:mcp": "node index.js serve"
-  },
-  "keywords": [
-    "mcp",
-    "cursor",
-    "windsurf",
-    "copilot",
-    "ai-context",
-    "vibecheck"
-  ],
-  "author": "vibecheck",
-  "license": "MIT"
-}

package/bin/runners/context/memory.js

@@ -1,200 +0,0 @@
-/**
- * AI Memory System Module
- * Self-learning memory that persists across projects
- */
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-const crypto = require("crypto");
-
-// Global memory directory
-const VIBECHECK_HOME = path.join(os.homedir(), ".vibecheck");
-const MEMORY_FILE = path.join(VIBECHECK_HOME, "global-memory.json");
-
-/**
- * Initialize global memory directory
- */
-function initializeMemory() {
-  if (!fs.existsSync(VIBECHECK_HOME)) {
-    fs.mkdirSync(VIBECHECK_HOME, { recursive: true });
-  }
-  
-  if (!fs.existsSync(MEMORY_FILE)) {
-    fs.writeFileSync(MEMORY_FILE, JSON.stringify({
-      version: "1.0.0",
-      created: new Date().toISOString(),
-      projects: {},
-      learnings: [],
-      patterns: {},
-      preferences: {},
-    }, null, 2));
-  }
-}
-
-/**
- * Load global AI memory
- */
-function loadMemory() {
-  initializeMemory();
-  try {
-    return JSON.parse(fs.readFileSync(MEMORY_FILE, "utf-8"));
-  } catch {
-    return { projects: {}, learnings: [], patterns: {}, preferences: {} };
-  }
-}
-
-/**
- * Save to global AI memory
- */
-function saveMemory(memory) {
-  initializeMemory();
-  fs.writeFileSync(MEMORY_FILE, JSON.stringify(memory, null, 2));
-}
-
-/**
- * Learn from project analysis and update memory
- */
-function learnFromProject(projectPath, analysis) {
-  const memory = loadMemory();
-  const projectId = crypto.createHash("md5").update(projectPath).digest("hex").slice(0, 8);
-  
-  // Store project info
-  memory.projects[projectId] = {
-    path: projectPath,
-    name: analysis.name,
-    framework: analysis.framework,
-    language: analysis.language,
-    lastAnalyzed: new Date().toISOString(),
-    patterns: analysis.patterns,
-    stats: analysis.stats,
-  };
-
-  // Learn patterns across projects
-  if (analysis.patterns?.stateManagement) {
-    memory.patterns.stateManagement = memory.patterns.stateManagement || {};
-    memory.patterns.stateManagement[analysis.patterns.stateManagement] = 
-      (memory.patterns.stateManagement[analysis.patterns.stateManagement] || 0) + 1;
-  }
-
-  if (analysis.patterns?.validation) {
-    memory.patterns.validation = memory.patterns.validation || {};
-    memory.patterns.validation[analysis.patterns.validation] = 
-      (memory.patterns.validation[analysis.patterns.validation] || 0) + 1;
-  }
-
-  if (analysis.framework) {
-    memory.patterns.frameworks = memory.patterns.frameworks || {};
-    memory.patterns.frameworks[analysis.framework] = 
-      (memory.patterns.frameworks[analysis.framework] || 0) + 1;
-  }
-
-  // Add learning entry
-  memory.learnings.push({
-    timestamp: new Date().toISOString(),
-    project: analysis.name,
-    action: "context_generated",
-    details: {
-      files: analysis.stats?.totalFiles || 0,
-      components: analysis.components?.length || 0,
-      hooks: analysis.patterns?.hooks?.length || 0,
-    },
-  });
-
-  // Keep only last 100 learnings
-  if (memory.learnings.length > 100) {
-    memory.learnings = memory.learnings.slice(-100);
-  }
-
-  saveMemory(memory);
-  return memory;
-}
-
-/**
- * Get recommendations based on learned patterns
- */
-function getRecommendations(analysis) {
-  const memory = loadMemory();
-  const recommendations = [];
-
-  // Recommend popular patterns from other projects
-  if (!analysis.patterns?.stateManagement && memory.patterns.stateManagement) {
-    const popular = Object.entries(memory.patterns.stateManagement)
-      .sort((a, b) => b[1] - a[1])[0];
-    if (popular) {
-      recommendations.push({
-        type: "state_management",
-        message: `Consider using ${popular[0]} for state management (used in ${popular[1]} of your projects)`,
-      });
-    }
-  }
-
-  if (!analysis.patterns?.validation && memory.patterns.validation) {
-    const popular = Object.entries(memory.patterns.validation)
-      .sort((a, b) => b[1] - a[1])[0];
-    if (popular) {
-      recommendations.push({
-        type: "validation",
-        message: `Consider using ${popular[0]} for validation (used in ${popular[1]} of your projects)`,
-      });
-    }
-  }
-
-  return recommendations;
-}
-
-/**
- * Get memory statistics
- */
-function getMemoryStats() {
-  const memory = loadMemory();
-  return {
-    projectCount: Object.keys(memory.projects || {}).length,
-    learningCount: memory.learnings?.length || 0,
-    patterns: memory.patterns || {},
-    created: memory.created,
-  };
-}
-
-/**
- * Clear memory for a specific project
- */
-function clearProjectMemory(projectPath) {
-  const memory = loadMemory();
-  const projectId = crypto.createHash("md5").update(projectPath).digest("hex").slice(0, 8);
-  
-  if (memory.projects[projectId]) {
-    delete memory.projects[projectId];
-    saveMemory(memory);
-    return true;
-  }
-  return false;
-}
-
-/**
- * Clear all memory
- */
-function clearAllMemory() {
-  const memory = {
-    version: "1.0.0",
-    created: new Date().toISOString(),
-    projects: {},
-    learnings: [],
-    patterns: {},
-    preferences: {},
-  };
-  saveMemory(memory);
-}
-
-module.exports = {
-  VIBECHECK_HOME,
-  MEMORY_FILE,
-  initializeMemory,
-  loadMemory,
-  saveMemory,
-  learnFromProject,
-  getRecommendations,
-  getMemoryStats,
-  clearProjectMemory,
-  clearAllMemory,
-};

package/bin/runners/context/monorepo.js

@@ -1,215 +0,0 @@
-/**
- * Monorepo Detection Module
- * Detects monorepo structures and workspaces
- */
-
-const fs = require("fs");
-const path = require("path");
-
-/**
- * Find workspaces from glob patterns
- */
-function findWorkspaces(projectPath, patterns) {
-  const workspaces = [];
-  
-  for (const pattern of patterns) {
-    const baseDir = pattern.replace(/\/\*$/, "").replace(/\*\*$/, "");
-    const searchPath = path.join(projectPath, baseDir);
-    
-    if (fs.existsSync(searchPath) && fs.statSync(searchPath).isDirectory()) {
-      try {
-        const entries = fs.readdirSync(searchPath, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.isDirectory()) {
-            const pkgJson = path.join(searchPath, entry.name, "package.json");
-            if (fs.existsSync(pkgJson)) {
-              try {
-                const pkg = JSON.parse(fs.readFileSync(pkgJson, "utf-8"));
-                workspaces.push({
-                  name: pkg.name || entry.name,
-                  path: path.join(baseDir, entry.name),
-                  description: pkg.description || "",
-                  dependencies: Object.keys(pkg.dependencies || {}),
-                  devDependencies: Object.keys(pkg.devDependencies || {}),
-                  version: pkg.version,
-                });
-              } catch {}
-            }
-          }
-        }
-      } catch {}
-    }
-  }
-
-  return workspaces;
-}
-
-/**
- * Find packages used across multiple workspaces
- */
-function findSharedPackages(projectPath, workspaces) {
-  const packageUsage = new Map();
-  
-  for (const workspace of workspaces) {
-    const allDeps = [...(workspace.dependencies || []), ...(workspace.devDependencies || [])];
-    for (const dep of allDeps) {
-      if (dep.startsWith("@") || !dep.includes("/")) {
-        packageUsage.set(dep, (packageUsage.get(dep) || 0) + 1);
-      }
-    }
-  }
-
-  // Return packages used in multiple workspaces
-  return Array.from(packageUsage.entries())
-    .filter(([_, count]) => count > 1)
-    .map(([name, count]) => ({ name, usedIn: count }))
-    .sort((a, b) => b.usedIn - a.usedIn)
-    .slice(0, 20);
-}
-
-/**
- * Detect if project is a monorepo and find all workspaces
- */
-function detectMonorepo(projectPath) {
-  const monorepo = {
-    isMonorepo: false,
-    type: null,
-    workspaces: [],
-    sharedPackages: [],
-    rootConfig: null,
-    tools: [],
-  };
-
-  const pkgPath = path.join(projectPath, "package.json");
-  if (!fs.existsSync(pkgPath)) return monorepo;
-
-  try {
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    
-    // Check for npm/yarn workspaces
-    if (pkg.workspaces) {
-      monorepo.isMonorepo = true;
-      monorepo.type = "npm/yarn";
-      const patterns = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages || [];
-      monorepo.workspaces = findWorkspaces(projectPath, patterns);
-    }
-
-    // Check for pnpm workspaces
-    const pnpmWorkspace = path.join(projectPath, "pnpm-workspace.yaml");
-    if (fs.existsSync(pnpmWorkspace)) {
-      monorepo.isMonorepo = true;
-      monorepo.type = "pnpm";
-      try {
-        const content = fs.readFileSync(pnpmWorkspace, "utf-8");
-        const patterns = content.match(/- ['"]?([^'"]+)['"]?/g)?.map(m => 
-          m.replace(/- ['"]?/, "").replace(/['"]?$/, "")
-        ) || [];
-        monorepo.workspaces = findWorkspaces(projectPath, patterns);
-      } catch {}
-    }
-
-    // Check for Turborepo
-    if (fs.existsSync(path.join(projectPath, "turbo.json"))) {
-      monorepo.tools.push("Turborepo");
-      if (!monorepo.type) monorepo.type = "turborepo";
-      monorepo.rootConfig = "turbo.json";
-    }
-
-    // Check for Nx
-    if (fs.existsSync(path.join(projectPath, "nx.json"))) {
-      monorepo.isMonorepo = true;
-      monorepo.tools.push("Nx");
-      if (!monorepo.type) monorepo.type = "nx";
-      monorepo.rootConfig = "nx.json";
-      
-      // Nx projects are in workspace.json or project.json files
-      const workspaceJson = path.join(projectPath, "workspace.json");
-      if (fs.existsSync(workspaceJson)) {
-        try {
-          const workspace = JSON.parse(fs.readFileSync(workspaceJson, "utf-8"));
-          if (workspace.projects) {
-            for (const [name, config] of Object.entries(workspace.projects)) {
-              const projectPath = typeof config === "string" ? config : config.root;
-              monorepo.workspaces.push({
-                name,
-                path: projectPath,
-                description: "",
-                dependencies: [],
-              });
-            }
-          }
-        } catch {}
-      }
-    }
-
-    // Check for Lerna
-    if (fs.existsSync(path.join(projectPath, "lerna.json"))) {
-      monorepo.isMonorepo = true;
-      monorepo.tools.push("Lerna");
-      if (!monorepo.type) monorepo.type = "lerna";
-      monorepo.rootConfig = "lerna.json";
-      
-      try {
-        const lerna = JSON.parse(fs.readFileSync(path.join(projectPath, "lerna.json"), "utf-8"));
-        if (lerna.packages && monorepo.workspaces.length === 0) {
-          monorepo.workspaces = findWorkspaces(projectPath, lerna.packages);
-        }
-      } catch {}
-    }
-
-    // Check for Rush
-    if (fs.existsSync(path.join(projectPath, "rush.json"))) {
-      monorepo.isMonorepo = true;
-      monorepo.tools.push("Rush");
-      if (!monorepo.type) monorepo.type = "rush";
-      monorepo.rootConfig = "rush.json";
-    }
-
-    // Find shared packages
-    if (monorepo.isMonorepo && monorepo.workspaces.length > 0) {
-      monorepo.sharedPackages = findSharedPackages(projectPath, monorepo.workspaces);
-    }
-  } catch {}
-
-  return monorepo;
-}
-
-/**
- * Get workspace by name
- */
-function getWorkspace(projectPath, workspaceName) {
-  const monorepo = detectMonorepo(projectPath);
-  return monorepo.workspaces.find(w => w.name === workspaceName);
-}
-
-/**
- * Get internal dependencies (workspaces that depend on other workspaces)
- */
-function getInternalDependencies(projectPath) {
-  const monorepo = detectMonorepo(projectPath);
-  if (!monorepo.isMonorepo) return [];
-
-  const workspaceNames = new Set(monorepo.workspaces.map(w => w.name));
-  const internalDeps = [];
-
-  for (const workspace of monorepo.workspaces) {
-    const deps = [...(workspace.dependencies || []), ...(workspace.devDependencies || [])];
-    const internal = deps.filter(d => workspaceNames.has(d));
-    if (internal.length > 0) {
-      internalDeps.push({
-        workspace: workspace.name,
-        dependsOn: internal,
-      });
-    }
-  }
-
-  return internalDeps;
-}
-
-module.exports = {
-  detectMonorepo,
-  findWorkspaces,
-  findSharedPackages,
-  getWorkspace,
-  getInternalDependencies,
-};