@vibecheckai/cli 3.0.2 → 3.0.3

package/bin/runners/lib/contracts/route-contract.js

@@ -1,192 +0,0 @@
-/**
- * Route Contract Builder
- * Builds routes.json contract from truthpack
- */
-
-"use strict";
-
-const crypto = require("crypto");
-
-function sha256(text) {
-  return crypto.createHash("sha256").update(text).digest("hex").slice(0, 16);
-}
-
-/**
- * Build routes contract from truthpack
- */
-function buildRouteContract(truthpack) {
-  const contract = {
-    version: "1.0.0",
-    generatedAt: new Date().toISOString(),
-    routes: []
-  };
-
-  const serverRoutes = truthpack?.routes?.server || [];
-
-  for (const route of serverRoutes) {
-    const routeSpec = {
-      id: `route_${sha256(route.method + "_" + route.path)}`,
-      method: route.method,
-      path: route.path,
-      handler: route.handler || "unknown",
-      auth: inferAuthRequirement(route, truthpack),
-      roles: inferRoles(route, truthpack),
-      confidence: route.confidence || "med",
-      evidence: route.evidence || []
-    };
-
-    contract.routes.push(routeSpec);
-  }
-
-  return contract;
-}
-
-/**
- * Infer auth requirement from route and truthpack
- */
-function inferAuthRequirement(route, truthpack) {
-  const authPatterns = truthpack?.auth?.nextMatcherPatterns || [];
-  const path = route.path;
-
-  // Check if path matches any protected pattern
-  for (const pattern of authPatterns) {
-    if (matchesPattern(path, pattern)) {
-      return "required";
-    }
-  }
-
-  // Check for auth hooks in Fastify
-  if (route.hooks?.includes("onRequest") || route.hooks?.includes("preHandler")) {
-    return "required";
-  }
-
-  // Check for public API patterns
-  if (path.includes("/public/") || path.includes("/health") || path.includes("/status")) {
-    return "none";
-  }
-
-  return "optional";
-}
-
-/**
- * Infer roles from route metadata
- */
-function inferRoles(route, truthpack) {
-  const roles = [];
-
-  // Check for admin patterns in path
-  if (route.path.includes("/admin")) {
-    roles.push("admin");
-  }
-
-  // Check handler for role patterns
-  const handler = route.handler || "";
-  if (handler.includes("admin")) {
-    roles.push("admin");
-  }
-
-  return roles.length > 0 ? roles : undefined;
-}
-
-function matchesPattern(path, pattern) {
-  // Simple pattern matching
-  const normPattern = pattern.replace(/\*/g, ".*").replace(/\//g, "\\/");
-  try {
-    const rx = new RegExp(`^${normPattern}`, "i");
-    return rx.test(path);
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Validate code against route contract
- */
-function validateAgainstRouteContract(contract, clientRefs) {
-  const violations = [];
-  const contractPaths = new Map(contract.routes.map(r => [`${r.method}_${r.path}`, r]));
-
-  for (const ref of clientRefs) {
-    const key = `${ref.method}_${ref.path}`;
-    const wildcardKey = `*_${ref.path}`;
-
-    if (!contractPaths.has(key) && !contractPaths.has(wildcardKey)) {
-      // Check parameterized match
-      const match = findParameterizedMatch(contract.routes, ref.method, ref.path);
-      
-      if (!match) {
-        violations.push({
-          type: "undeclared_route",
-          severity: "BLOCK",
-          route: { method: ref.method, path: ref.path },
-          source: ref.source,
-          message: `Route ${ref.method} ${ref.path} used in client but not declared in contract`,
-          evidence: ref.evidence || []
-        });
-      }
-    }
-  }
-
-  return violations;
-}
-
-function findParameterizedMatch(routes, method, path) {
-  for (const r of routes) {
-    if (r.method !== "*" && r.method !== method) continue;
-    if (matchesParameterized(r.path, path)) return r;
-  }
-  return null;
-}
-
-function matchesParameterized(pattern, actual) {
-  const patternParts = pattern.split("/").filter(Boolean);
-  const actualParts = actual.split("/").filter(Boolean);
-
-  if (patternParts.length !== actualParts.length) return false;
-
-  for (let i = 0; i < patternParts.length; i++) {
-    const p = patternParts[i];
-    if (p.startsWith(":") || p.startsWith("*")) continue;
-    if (p !== actualParts[i]) return false;
-  }
-  return true;
-}
-
-/**
- * Diff two route contracts
- */
-function diffRouteContracts(before, after) {
-  const diff = {
-    added: [],
-    removed: [],
-    changed: []
-  };
-
-  const beforeMap = new Map(before.routes.map(r => [r.id, r]));
-  const afterMap = new Map(after.routes.map(r => [r.id, r]));
-
-  for (const [id, route] of afterMap) {
-    if (!beforeMap.has(id)) {
-      diff.added.push(route);
-    } else {
-      const prev = beforeMap.get(id);
-      if (prev.auth !== route.auth || JSON.stringify(prev.roles) !== JSON.stringify(route.roles)) {
-        diff.changed.push({ before: prev, after: route });
-      }
-    }
-  }
-
-  for (const [id, route] of beforeMap) {
-    if (!afterMap.has(id)) {
-      diff.removed.push(route);
-    }
-  }
-
-  return diff;
-}
-
-module.exports = {
-  buildRouteContract,
-  validateAgainstRouteContract,
-  diffRouteContracts
-};

package/bin/runners/lib/detect.js

@@ -1,89 +0,0 @@
-// bin/runners/lib/detect.js
-const fs = require("fs");
-const path = require("path");
-const fg = require("fast-glob");
-
-function fileExists(root, rel) {
-  return fs.existsSync(path.join(root, rel));
-}
-
-function detectPackageManager(root) {
-  if (fileExists(root, "pnpm-lock.yaml")) return "pnpm";
-  if (fileExists(root, "yarn.lock")) return "yarn";
-  if (fileExists(root, "package-lock.json")) return "npm";
-  return "npm";
-}
-
-function detectNext(root, pkg) {
-  const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-  const hasDep = !!deps.next;
-  const hasConfig = fileExists(root, "next.config.js") || fileExists(root, "next.config.mjs") || fileExists(root, "next.config.ts");
-  const hasApp = fileExists(root, "app") || fileExists(root, "src/app");
-  const hasPages = fileExists(root, "pages") || fileExists(root, "src/pages");
-  return { enabled: hasDep || hasConfig || hasApp || hasPages, hasDep, hasConfig, hasApp, hasPages };
-}
-
-function detectFastify(root, pkg) {
-  const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-  const hasDep = !!deps.fastify;
-  return { enabled: hasDep, hasDep };
-}
-
-function scoreFastifyEntry(code, rel) {
-  let s = 0;
-  if (/\bfastify\s*\(/.test(code)) s += 10;
-  if (/from\s+['"]fastify['"]|require\(['"]fastify['"]\)/.test(code)) s += 8;
-  if (/\baddHook\s*\(/.test(code)) s += 2;
-  if (/\bregister\s*\(/.test(code)) s += 2;
-  if (/\.(listen|ready)\s*\(/.test(code)) s += 10;
-  if (/createServer|http\.createServer/.test(code)) s += 1;
-  if (rel.includes("server")) s += 2;
-  if (rel.includes("api")) s += 1;
-  if (rel.endsWith(".ts")) s += 1;
-  return s;
-}
-
-async function detectFastifyEntry(root) {
-  const common = [
-    "src/server.ts", "src/server.js",
-    "server.ts", "server.js",
-    "src/index.ts", "src/index.js",
-    "index.ts", "index.js",
-    "src/app.ts", "src/app.js",
-    "app.ts", "app.js"
-  ];
-
-  for (const rel of common) {
-    const abs = path.join(root, rel);
-    if (!fs.existsSync(abs)) continue;
-    const code = fs.readFileSync(abs, "utf8");
-    if (/\bfastify\s*\(/.test(code)) return rel;
-  }
-
-  const files = await fg(["**/*.{ts,js}"], {
-    cwd: root,
-    onlyFiles: true,
-    absolute: false,
-    ignore: ["**/node_modules/**", "**/.next/**", "**/dist/**", "**/build/**"]
-  });
-
-  let best = null;
-  for (const rel of files.slice(0, 800)) {
-    const abs = path.join(root, rel);
-    let code;
-    try { code = fs.readFileSync(abs, "utf8"); } catch { continue; }
-    if (!/\bfastify\s*\(/.test(code)) continue;
-
-    const s = scoreFastifyEntry(code, rel);
-    if (!best || s > best.score) best = { rel, score: s };
-  }
-
-  return best?.rel || null;
-}
-
-module.exports = {
-  detectPackageManager,
-  detectNext,
-  detectFastify,
-  detectFastifyEntry
-};

package/bin/runners/lib/doctor/autofix.js

@@ -1,254 +0,0 @@
-/**
- * Doctor Auto-Fix Engine
- * 
- * Executes fixes for diagnostic issues automatically when safe
- */
-
-const fs = require('fs');
-const path = require('path');
-const { execSync, spawn } = require('child_process');
-const { FIX_TYPE, SEVERITY } = require('./types');
-
-const FIX_RESULT = {
-  SUCCESS: 'success',
-  FAILED: 'failed',
-  SKIPPED: 'skipped',
-  REQUIRES_CONFIRMATION: 'requires_confirmation',
-};
-
-function canAutoFix(fix) {
-  if (!fix) return false;
-  if (fix.dangerous) return false;
-  if (fix.autoFixable === false) return false;
-  
-  // Only auto-fix commands and file operations
-  return [FIX_TYPE.COMMAND, FIX_TYPE.FILE_CREATE, FIX_TYPE.FILE_EDIT].includes(fix.type);
-}
-
-async function executeFix(fix, projectPath, options = {}) {
-  const { dryRun = false, interactive = false } = options;
-  
-  if (!fix) {
-    return { status: FIX_RESULT.SKIPPED, reason: 'No fix provided' };
-  }
-  
-  if (fix.dangerous && !options.allowDangerous) {
-    return { 
-      status: FIX_RESULT.REQUIRES_CONFIRMATION, 
-      reason: 'Fix is marked as dangerous',
-      fix,
-    };
-  }
-  
-  if (dryRun) {
-    return { 
-      status: FIX_RESULT.SKIPPED, 
-      reason: 'Dry run mode',
-      wouldExecute: fix,
-    };
-  }
-  
-  try {
-    switch (fix.type) {
-      case FIX_TYPE.COMMAND:
-        return await executeCommand(fix, projectPath, options);
-      
-      case FIX_TYPE.FILE_CREATE:
-        return await createFile(fix, projectPath);
-      
-      case FIX_TYPE.FILE_EDIT:
-        return await editFile(fix, projectPath);
-      
-      case FIX_TYPE.MANUAL:
-        return { 
-          status: FIX_RESULT.SKIPPED, 
-          reason: 'Manual fix required',
-          instructions: fix.description,
-        };
-      
-      case FIX_TYPE.LINK:
-        return { 
-          status: FIX_RESULT.SKIPPED, 
-          reason: 'External documentation',
-          url: fix.url,
-        };
-      
-      default:
-        return { 
-          status: FIX_RESULT.SKIPPED, 
-          reason: `Unknown fix type: ${fix.type}`,
-        };
-    }
-  } catch (err) {
-    return {
-      status: FIX_RESULT.FAILED,
-      error: err.message,
-      fix,
-    };
-  }
-}
-
-async function executeCommand(fix, projectPath, options = {}) {
-  const { timeout = 60000 } = options;
-  
-  if (!fix.command) {
-    return { status: FIX_RESULT.SKIPPED, reason: 'No command specified' };
-  }
-  
-  try {
-    const result = execSync(fix.command, {
-      cwd: projectPath,
-      encoding: 'utf8',
-      timeout,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    
-    return {
-      status: FIX_RESULT.SUCCESS,
-      command: fix.command,
-      output: result.trim(),
-    };
-  } catch (err) {
-    return {
-      status: FIX_RESULT.FAILED,
-      command: fix.command,
-      error: err.message,
-      stderr: err.stderr,
-    };
-  }
-}
-
-async function createFile(fix, projectPath) {
-  if (!fix.path || fix.content === undefined) {
-    return { status: FIX_RESULT.SKIPPED, reason: 'No path or content specified' };
-  }
-  
-  const fullPath = path.isAbsolute(fix.path) ? fix.path : path.join(projectPath, fix.path);
-  
-  // Don't overwrite existing files
-  if (fs.existsSync(fullPath)) {
-    return { 
-      status: FIX_RESULT.SKIPPED, 
-      reason: 'File already exists',
-      path: fullPath,
-    };
-  }
-  
-  // Ensure directory exists
-  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-  
-  // Write file
-  fs.writeFileSync(fullPath, fix.content);
-  
-  return {
-    status: FIX_RESULT.SUCCESS,
-    action: 'created',
-    path: fullPath,
-  };
-}
-
-async function editFile(fix, projectPath) {
-  if (!fix.path || fix.content === undefined) {
-    return { status: FIX_RESULT.SKIPPED, reason: 'No path or content specified' };
-  }
-  
-  const fullPath = path.isAbsolute(fix.path) ? fix.path : path.join(projectPath, fix.path);
-  
-  // Backup existing file
-  if (fs.existsSync(fullPath)) {
-    const backupPath = `${fullPath}.doctor-backup`;
-    fs.copyFileSync(fullPath, backupPath);
-  }
-  
-  // Write new content
-  fs.writeFileSync(fullPath, fix.content);
-  
-  return {
-    status: FIX_RESULT.SUCCESS,
-    action: 'edited',
-    path: fullPath,
-  };
-}
-
-async function autoFixAll(diagnostics, projectPath, options = {}) {
-  const { 
-    dryRun = false, 
-    severity = [SEVERITY.CRITICAL, SEVERITY.ERROR],
-    maxFixes = 10,
-  } = options;
-  
-  const results = [];
-  let fixCount = 0;
-  
-  // Sort by severity (critical first)
-  const severityOrder = [SEVERITY.CRITICAL, SEVERITY.ERROR, SEVERITY.WARNING];
-  const sortedDiagnostics = [...diagnostics].sort((a, b) => {
-    return severityOrder.indexOf(a.severity) - severityOrder.indexOf(b.severity);
-  });
-  
-  for (const diagnostic of sortedDiagnostics) {
-    if (fixCount >= maxFixes) break;
-    if (!severity.includes(diagnostic.severity)) continue;
-    if (!diagnostic.fixes || diagnostic.fixes.length === 0) continue;
-    
-    // Try the first auto-fixable fix
-    const fix = diagnostic.fixes.find(f => canAutoFix(f));
-    if (!fix) continue;
-    
-    const result = await executeFix(fix, projectPath, { ...options, dryRun });
-    results.push({
-      diagnosticId: diagnostic.id,
-      diagnosticName: diagnostic.name,
-      ...result,
-    });
-    
-    if (result.status === FIX_RESULT.SUCCESS) {
-      fixCount++;
-    }
-  }
-  
-  return {
-    attempted: results.length,
-    succeeded: results.filter(r => r.status === FIX_RESULT.SUCCESS).length,
-    failed: results.filter(r => r.status === FIX_RESULT.FAILED).length,
-    skipped: results.filter(r => r.status === FIX_RESULT.SKIPPED).length,
-    results,
-  };
-}
-
-function getFixCommands(diagnostics, options = {}) {
-  const { severity = [SEVERITY.CRITICAL, SEVERITY.ERROR, SEVERITY.WARNING] } = options;
-  
-  const commands = [];
-  
-  for (const diagnostic of diagnostics) {
-    if (!severity.includes(diagnostic.severity)) continue;
-    if (!diagnostic.fixes) continue;
-    
-    for (const fix of diagnostic.fixes) {
-      if (fix.type === FIX_TYPE.COMMAND && fix.command) {
-        commands.push({
-          diagnosticId: diagnostic.id,
-          diagnosticName: diagnostic.name,
-          command: fix.command,
-          description: fix.description,
-          dangerous: fix.dangerous,
-          autoFixable: canAutoFix(fix),
-        });
-      }
-    }
-  }
-  
-  return commands;
-}
-
-module.exports = {
-  FIX_RESULT,
-  canAutoFix,
-  executeFix,
-  executeCommand,
-  createFile,
-  editFile,
-  autoFixAll,
-  getFixCommands,
-};

package/bin/runners/lib/doctor/index.js

@@ -1,37 +0,0 @@
-/**
- * Doctor Service — Enterprise Environment Diagnostics
- * 
- * Main entry point for the Doctor service
- */
-
-const { DoctorService, diagnose } = require('./service');
-const { SEVERITY, CATEGORY, FIX_TYPE, SEVERITY_WEIGHT, CATEGORY_META } = require('./types');
-const modules = require('./modules');
-const reporter = require('./reporter');
-const autofix = require('./autofix');
-const ui = require('./ui');
-
-module.exports = {
-  // Main service
-  DoctorService,
-  diagnose,
-  
-  // Types and constants
-  SEVERITY,
-  CATEGORY,
-  FIX_TYPE,
-  SEVERITY_WEIGHT,
-  CATEGORY_META,
-  
-  // Modules
-  modules,
-  
-  // Reporter
-  reporter,
-  
-  // Auto-fix
-  autofix,
-  
-  // UI utilities
-  ui,
-};