@vibecheckai/cli 3.5.0 → 3.5.2

package/mcp-server/lib/cache-wrapper.cjs

@@ -0,0 +1,383 @@
+/**
+ * Cache Wrapper for MCP Server (CommonJS)
+ *
+ * Provides cache integration for vibecheck MCP tools.
+ * Wraps tool execution with caching and returns cacheStats.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const os = require('os');
+
+// =============================================================================
+// CONFIGURATION
+// =============================================================================
+
+const CACHE_VERSION = '1.0.0';
+const CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
+const CACHE_MAX_ENTRIES = 100;
+const SCHEMA_VERSION = '1.0.0';
+
+const CONFIG_FILES = ['.vibecheckrc.json', '.vibecheckrc', 'vibecheck.config.js'];
+const LOCKFILES = ['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock', 'bun.lockb'];
+
+// =============================================================================
+// CACHE UTILITIES
+// =============================================================================
+
+function getCacheDir() {
+  const home = os.homedir();
+  if (process.platform === 'win32') {
+    return path.join(
+      process.env.APPDATA || path.join(home, 'AppData', 'Roaming'),
+      'vibecheck',
+      'cache',
+      'runs'
+    );
+  }
+  return path.join(home, '.cache', 'vibecheck', 'runs');
+}
+
+function getCacheFilePath(projectPath) {
+  const cacheDir = getCacheDir();
+  const projectHash = crypto
+    .createHash('sha256')
+    .update(path.resolve(projectPath))
+    .digest('hex')
+    .slice(0, 16);
+  return path.join(cacheDir, `tool-cache-${projectHash}.json`);
+}
+
+function ensureCacheDir() {
+  const cacheDir = getCacheDir();
+  if (!fs.existsSync(cacheDir)) {
+    fs.mkdirSync(cacheDir, { recursive: true, mode: 0o700 });
+  }
+}
+
+function computeFileHash(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const content = fs.readFileSync(filePath);
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+  } catch {
+    return null;
+  }
+}
+
+function hashString(str) {
+  return crypto.createHash('sha256').update(str).digest('hex').slice(0, 16);
+}
+
+function computeRepoFingerprint(projectPath) {
+  const components = [];
+
+  // Hash config files
+  for (const configFile of CONFIG_FILES) {
+    const configPath = path.join(projectPath, configFile);
+    const hash = computeFileHash(configPath);
+    if (hash) {
+      components.push(`config:${configFile}:${hash}`);
+    }
+  }
+
+  // Hash lockfiles
+  for (const lockfile of LOCKFILES) {
+    const lockPath = path.join(projectPath, lockfile);
+    const hash = computeFileHash(lockPath);
+    if (hash) {
+      components.push(`lock:${lockfile}:${hash}`);
+    }
+  }
+
+  // Hash root package.json
+  const manifestPath = path.join(projectPath, 'package.json');
+  const manifestHash = computeFileHash(manifestPath);
+  if (manifestHash) {
+    components.push(`manifest:root:${manifestHash}`);
+  }
+
+  const combined = components.sort().join('|');
+  return hashString(combined);
+}
+
+function generateCacheKey(toolName, projectPath, vibecheckVersion) {
+  const repoFingerprint = computeRepoFingerprint(projectPath);
+  return {
+    toolName,
+    vibecheckVersion,
+    schemaVersion: SCHEMA_VERSION,
+    repoFingerprint,
+  };
+}
+
+function cacheKeyToString(key) {
+  return `${key.toolName}:${key.vibecheckVersion}:${key.schemaVersion}:${key.repoFingerprint}`;
+}
+
+function loadCacheStore(projectPath) {
+  try {
+    const cachePath = getCacheFilePath(projectPath);
+    if (!fs.existsSync(cachePath)) {
+      return { version: CACHE_VERSION, entries: {} };
+    }
+
+    const data = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+
+    if (data.version !== CACHE_VERSION) {
+      return { version: CACHE_VERSION, entries: {} };
+    }
+
+    // Prune old entries
+    const now = Date.now();
+    const entries = {};
+    for (const [keyStr, entry] of Object.entries(data.entries)) {
+      const createdAt = new Date(entry.createdAt).getTime();
+      if (now - createdAt < CACHE_MAX_AGE_MS) {
+        entries[keyStr] = entry;
+      }
+    }
+
+    return { version: CACHE_VERSION, entries };
+  } catch {
+    return { version: CACHE_VERSION, entries: {} };
+  }
+}
+
+function saveCacheStore(projectPath, store) {
+  try {
+    ensureCacheDir();
+    const cachePath = getCacheFilePath(projectPath);
+    const tempPath = `${cachePath}.tmp.${Date.now()}`;
+
+    // Limit cache size
+    const entries = Object.entries(store.entries);
+    if (entries.length > CACHE_MAX_ENTRIES) {
+      entries.sort((a, b) => {
+        const aTime = new Date(a[1].createdAt).getTime();
+        const bTime = new Date(b[1].createdAt).getTime();
+        return bTime - aTime;
+      });
+      store.entries = Object.fromEntries(entries.slice(0, CACHE_MAX_ENTRIES));
+    }
+
+    fs.writeFileSync(tempPath, JSON.stringify(store, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, cachePath);
+  } catch (err) {
+    if (process.env.DEBUG || process.env.VIBECHECK_DEBUG) {
+      console.warn(`Cache save failed: ${err.message}`);
+    }
+  }
+}
+
+function buildFileHashMap(projectPath, files) {
+  const hashMap = {};
+  for (const file of files) {
+    const fullPath = path.isAbsolute(file) ? file : path.join(projectPath, file);
+    const hash = computeFileHash(fullPath);
+    if (hash) {
+      const relPath = path.relative(projectPath, fullPath).replace(/\\/g, '/');
+      hashMap[relPath] = hash;
+    }
+  }
+  return hashMap;
+}
+
+// =============================================================================
+// CACHE CLASS
+// =============================================================================
+
+class ToolCache {
+  constructor(projectPath, options = {}) {
+    this.projectPath = path.resolve(projectPath);
+    this.vibecheckVersion = options.vibecheckVersion || '3.3.0';
+    this.enabled = options.enabled !== false;
+    this.store = this.enabled ? loadCacheStore(this.projectPath) : { version: CACHE_VERSION, entries: {} };
+  }
+
+  get(toolName) {
+    if (!this.enabled) return null;
+
+    const key = generateCacheKey(toolName, this.projectPath, this.vibecheckVersion);
+    const keyStr = cacheKeyToString(key);
+    const entry = this.store.entries[keyStr];
+
+    if (entry) {
+      // Verify fingerprint still matches
+      const currentFingerprint = computeRepoFingerprint(this.projectPath);
+      if (currentFingerprint !== key.repoFingerprint) {
+        delete this.store.entries[keyStr];
+        return null;
+      }
+
+      return {
+        entry,
+        stats: {
+          hit: true,
+          reusedFindingsCount: entry.output.findings?.length || 0,
+          durationMs: 0,
+        },
+      };
+    }
+
+    return null;
+  }
+
+  set(toolName, output, fileHashMap, durationMs) {
+    if (!this.enabled) return;
+
+    const key = generateCacheKey(toolName, this.projectPath, this.vibecheckVersion);
+    const keyStr = cacheKeyToString(key);
+
+    const entry = {
+      key,
+      output,
+      fileHashMap,
+      createdAt: new Date().toISOString(),
+      durationMs,
+      vibecheckVersion: this.vibecheckVersion,
+      schemaVersion: SCHEMA_VERSION,
+    };
+
+    this.store.entries[keyStr] = entry;
+    saveCacheStore(this.projectPath, this.store);
+  }
+
+  invalidate(toolName) {
+    if (!this.enabled) return;
+
+    const key = generateCacheKey(toolName, this.projectPath, this.vibecheckVersion);
+    const keyStr = cacheKeyToString(key);
+    delete this.store.entries[keyStr];
+    saveCacheStore(this.projectPath, this.store);
+  }
+
+  invalidateAll() {
+    if (!this.enabled) return;
+    this.store.entries = {};
+    saveCacheStore(this.projectPath, this.store);
+  }
+}
+
+// =============================================================================
+// EXECUTE WITH CACHE
+// =============================================================================
+
+/**
+ * Execute a tool with caching support
+ * @param {Object} options - Tool options
+ * @param {Function} executor - Tool executor function
+ * @returns {Promise<Object>} Result with cacheStats
+ */
+async function executeWithCache(options, executor) {
+  const startTime = Date.now();
+  const {
+    projectPath,
+    toolName,
+    useCache = true,
+    forceRefresh = false,
+    files = [],
+    vibecheckVersion = '3.3.0',
+  } = options;
+
+  const cache = new ToolCache(projectPath, {
+    vibecheckVersion,
+    enabled: useCache,
+  });
+
+  // Check for cache hit
+  if (!forceRefresh) {
+    const cached = cache.get(toolName);
+    if (cached) {
+      return {
+        ...cached.entry.output,
+        cacheStats: {
+          hit: true,
+          reusedFindingsCount: cached.entry.output.findings?.length || 0,
+          durationMs: Date.now() - startTime,
+        },
+      };
+    }
+  }
+
+  // Cache miss - execute tool
+  const result = await executor(options);
+  const durationMs = Date.now() - startTime;
+
+  // Build file hash map
+  const fileHashMap = files.length > 0 ? buildFileHashMap(projectPath, files) : {};
+
+  // Store in cache
+  const output = {
+    findings: result.findings || [],
+    verdict: result.verdict || null,
+    metadata: {
+      ...result.metadata,
+      cachedAt: new Date().toISOString(),
+    },
+  };
+
+  cache.set(toolName, output, fileHashMap, durationMs);
+
+  return {
+    ...result,
+    cacheStats: {
+      hit: false,
+      reusedFindingsCount: 0,
+      durationMs,
+    },
+  };
+}
+
+/**
+ * Wrap CLI command execution with caching
+ * @param {string} projectPath - Project path
+ * @param {string} toolName - Tool name
+ * @param {Function} cliExecutor - CLI executor function
+ * @param {Object} options - Additional options
+ * @returns {Promise<Object>} Result with cacheStats
+ */
+async function executeCachedCliCommand(projectPath, toolName, cliExecutor, options = {}) {
+  return executeWithCache(
+    {
+      projectPath,
+      toolName,
+      useCache: options.useCache !== false,
+      forceRefresh: options.forceRefresh || false,
+      files: options.files || [],
+      vibecheckVersion: options.vibecheckVersion || '3.3.0',
+    },
+    async () => cliExecutor()
+  );
+}
+
+// =============================================================================
+// EXPORTS
+// =============================================================================
+
+module.exports = {
+  ToolCache,
+  executeWithCache,
+  executeCachedCliCommand,
+  computeFileHash,
+  computeRepoFingerprint,
+  buildFileHashMap,
+  getCacheDir,
+  clearAllCaches: () => {
+    try {
+      const cacheDir = getCacheDir();
+      if (fs.existsSync(cacheDir)) {
+        const files = fs.readdirSync(cacheDir);
+        for (const file of files) {
+          if (file.startsWith('tool-cache-') && file.endsWith('.json')) {
+            fs.unlinkSync(path.join(cacheDir, file));
+          }
+        }
+      }
+      return { success: true, message: 'All tool caches cleared' };
+    } catch (err) {
+      return { success: false, message: `Failed to clear caches: ${err.message}` };
+    }
+  },
+};

package/mcp-server/lib/error-envelope.js

@@ -0,0 +1,138 @@
+/**
+ * MCP Error Envelope - consistent error format across all tools
+ * 
+ * Provides standardized error and success envelopes for all MCP tool responses.
+ * Ensures consistent error handling, timeout support, and cancellation.
+ */
+
+const ERROR_CODES = {
+  // Auth errors
+  AUTH_REQUIRED: { status: 401, message: 'Authentication required' },
+  AUTH_FAILED: { status: 401, message: 'Authentication failed' },
+  TIER_REQUIRED: { status: 403, message: 'Upgrade required for this feature' },
+  NOT_ENTITLED: { status: 403, message: 'Feature not available on current tier' },
+  OPTION_NOT_ENTITLED: { status: 403, message: 'Option requires higher tier' },
+  
+  // Validation errors
+  VALIDATION_ERROR: { status: 400, message: 'Invalid input' },
+  NOT_FOUND: { status: 404, message: 'Resource not found' },
+  TOOL_NOT_FOUND: { status: 404, message: 'Tool not found' },
+  
+  // Rate limiting
+  RATE_LIMITED: { status: 429, message: 'Too many requests' },
+  
+  // Execution errors
+  TIMEOUT: { status: 408, message: 'Operation timed out' },
+  CANCELLED: { status: 499, message: 'Operation cancelled' },
+  INTERNAL_ERROR: { status: 500, message: 'Internal error' },
+};
+
+/**
+ * Create a standard ErrorEnvelope for tool errors
+ * @param {string} code - Error code (AUTH_REQUIRED, TIER_REQUIRED, etc.)
+ * @param {string} message - Human-readable error message
+ * @param {object} details - Additional error details
+ * @returns {object} ErrorEnvelope
+ */
+function createErrorEnvelope(code, message, details = {}) {
+  const errorDef = ERROR_CODES[code] || ERROR_CODES.INTERNAL_ERROR;
+  
+  return {
+    success: false,
+    ok: false,
+    error: {
+      code,
+      message: message || errorDef.message,
+      status: errorDef.status,
+      ...details,
+    },
+    timestamp: new Date().toISOString(),
+  };
+}
+
+/**
+ * Create a success envelope for tool responses
+ * @param {*} data - Response data
+ * @param {object} metadata - Additional metadata (cacheStats, etc.)
+ * @returns {object} SuccessEnvelope
+ */
+function createSuccessEnvelope(data, metadata = {}) {
+  return {
+    success: true,
+    ok: true,
+    data,
+    ...metadata,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+/**
+ * Wrap tool execution with consistent error handling, timeout, and cancellation
+ * @param {string} toolName - Name of the tool being executed
+ * @param {Function} fn - Async function to execute (receives AbortSignal)
+ * @param {object} options - Options
+ * @param {number} options.timeout - Timeout in milliseconds (default: 30000)
+ * @returns {Promise<object>} Success or error envelope
+ */
+async function executeWithEnvelope(toolName, fn, options = {}) {
+  const timeout = options.timeout || 30000;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  
+  try {
+    const result = await Promise.race([
+      fn(controller.signal),
+      new Promise((_, reject) => {
+        controller.signal.addEventListener('abort', () => {
+          reject(new Error('TIMEOUT'));
+        });
+      }),
+    ]);
+    
+    clearTimeout(timeoutId);
+    return createSuccessEnvelope(result);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    
+    if (error.message === 'TIMEOUT') {
+      return createErrorEnvelope(
+        'TIMEOUT',
+        `${toolName} timed out after ${timeout}ms`,
+        { timeout, toolName }
+      );
+    }
+    
+    if (error.name === 'AbortError' || error.message === 'CANCELLED') {
+      return createErrorEnvelope(
+        'CANCELLED',
+        `${toolName} was cancelled`,
+        { toolName }
+      );
+    }
+    
+    // If error already has a code, preserve it
+    if (error.code && ERROR_CODES[error.code]) {
+      return createErrorEnvelope(
+        error.code,
+        error.message,
+        { ...error.details, toolName }
+      );
+    }
+    
+    return createErrorEnvelope(
+      'INTERNAL_ERROR',
+      error.message || 'An unexpected error occurred',
+      {
+        stack: process.env.NODE_ENV !== 'production' ? error.stack : undefined,
+        toolName,
+      }
+    );
+  }
+}
+
+module.exports = {
+  createErrorEnvelope,
+  createSuccessEnvelope,
+  executeWithEnvelope,
+  ERROR_CODES,
+};