@vibecheckai/cli 3.9.0 → 4.0.0

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

@@ -1,383 +0,0 @@
-/**
- * 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

@@ -1,138 +0,0 @@
-/**
- * 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,
-};