@vibecheckai/cli 2.8.2 → 3.0.0

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

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

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

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

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