vibecheck-ai 2.0.2 → 5.0.1

package/bin/runners/lib/schemas/validator.js

@@ -0,0 +1,465 @@
+/**
+ * Schema Validator v2
+ * 
+ * Validates artifacts against JSON schemas and provides
+ * consistent finding/evidence generation.
+ * 
+ * NOTE: This module now delegates to ajv-validator.js when AJV is available.
+ * The minimal implementation is kept as a fallback for environments without AJV.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+// Try to use the AJV-based validator if available
+let ajvValidator = null;
+try {
+  // Check if AJV is installed before requiring
+  require.resolve("ajv");
+  require.resolve("ajv-formats");
+  ajvValidator = require("./ajv-validator.js");
+} catch (e) {
+  // AJV not available, will use minimal validator
+  if (process.env.NODE_ENV === "production") {
+    console.warn("Warning: AJV not available, using minimal schema validator");
+  }
+}
+
+// If AJV validator is available, export it directly
+if (ajvValidator) {
+  module.exports = ajvValidator;
+  return;
+}
+
+// =============================================================================
+// MINIMAL VALIDATOR FALLBACK (when AJV is not available)
+// =============================================================================
+
+// Schema cache
+const schemaCache = new Map();
+
+// Schema IDs
+const SCHEMAS = {
+  FINDING: "finding.schema.json",
+  SHIP_REPORT: "ship-report.schema.json",
+  REALITY_REPORT: "reality-report.schema.json",
+  TRUTHPACK_V2: "truthpack-v2.schema.json",
+  CONTRACTS: "contracts.schema.json",
+  PROOF_GRAPH: "proof-graph.schema.json",
+  MISSION_PACK: "mission-pack.schema.json",
+  SHARE_PACK: "share-pack.schema.json",
+};
+
+// =============================================================================
+// SCHEMA LOADING
+// =============================================================================
+
+/**
+ * Load a schema by ID
+ */
+function loadSchema(schemaId) {
+  if (schemaCache.has(schemaId)) {
+    return schemaCache.get(schemaId);
+  }
+
+  const schemaPath = path.join(__dirname, schemaId);
+  if (!fs.existsSync(schemaPath)) {
+    return null;
+  }
+
+  try {
+    const schema = JSON.parse(fs.readFileSync(schemaPath, "utf8"));
+    schemaCache.set(schemaId, schema);
+    return schema;
+  } catch (e) {
+    console.error(`Failed to load schema ${schemaId}:`, e.message);
+    return null;
+  }
+}
+
+/**
+ * Simple JSON Schema validator (subset of draft 2020-12)
+ * For production, use Ajv - this is a minimal implementation
+ */
+function validateAgainstSchema(data, schema, path = "") {
+  const errors = [];
+
+  if (!schema || !data) {
+    return errors;
+  }
+
+  // Type check
+  if (schema.type) {
+    let actualType = Array.isArray(data) ? "array" : typeof data;
+    
+    // Handle integer type - JavaScript has no integer type, only number
+    // Treat whole numbers as integers for schema validation
+    if (actualType === "number" && Number.isInteger(data)) {
+      actualType = "integer";
+    }
+    
+    const allowedTypes = Array.isArray(schema.type) ? schema.type : [schema.type];
+    
+    // Allow integer where number is expected, and vice versa for whole numbers
+    const typeMatches = allowedTypes.some(t => {
+      if (t === actualType) return true;
+      if (t === "integer" && actualType === "number" && Number.isInteger(data)) return true;
+      if (t === "number" && actualType === "integer") return true;
+      if (t === "null" && data === null) return true;
+      return false;
+    });
+    
+    if (!typeMatches) {
+      errors.push({
+        path,
+        message: `Expected ${allowedTypes.join("|")}, got ${actualType}`,
+        keyword: "type",
+      });
+      return errors; // Stop on type mismatch
+    }
+  }
+
+  // Const check
+  if (schema.const !== undefined && data !== schema.const) {
+    errors.push({
+      path,
+      message: `Expected constant "${schema.const}", got "${data}"`,
+      keyword: "const",
+    });
+  }
+
+  // Enum check
+  if (schema.enum && !schema.enum.includes(data)) {
+    errors.push({
+      path,
+      message: `Value must be one of: ${schema.enum.join(", ")}`,
+      keyword: "enum",
+    });
+  }
+
+  // Pattern check
+  if (schema.pattern && typeof data === "string") {
+    const regex = new RegExp(schema.pattern);
+    if (!regex.test(data)) {
+      errors.push({
+        path,
+        message: `String must match pattern: ${schema.pattern}`,
+        keyword: "pattern",
+      });
+    }
+  }
+
+  // Required properties
+  if (schema.required && typeof data === "object" && !Array.isArray(data)) {
+    for (const prop of schema.required) {
+      if (!(prop in data)) {
+        errors.push({
+          path: path ? `${path}.${prop}` : prop,
+          message: `Required property "${prop}" is missing`,
+          keyword: "required",
+        });
+      }
+    }
+  }
+
+  // Object properties
+  if (schema.properties && typeof data === "object" && !Array.isArray(data)) {
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      if (key in data) {
+        const propPath = path ? `${path}.${key}` : key;
+        errors.push(...validateAgainstSchema(data[key], propSchema, propPath));
+      }
+    }
+  }
+
+  // Array items
+  if (schema.items && Array.isArray(data)) {
+    for (let i = 0; i < data.length; i++) {
+      const itemPath = `${path}[${i}]`;
+      errors.push(...validateAgainstSchema(data[i], schema.items, itemPath));
+    }
+  }
+
+  // Min/max length
+  if (schema.maxLength && typeof data === "string" && data.length > schema.maxLength) {
+    errors.push({
+      path,
+      message: `String length must be <= ${schema.maxLength}`,
+      keyword: "maxLength",
+    });
+  }
+
+  // Min/max for numbers
+  if (schema.minimum !== undefined && typeof data === "number" && data < schema.minimum) {
+    errors.push({
+      path,
+      message: `Value must be >= ${schema.minimum}`,
+      keyword: "minimum",
+    });
+  }
+  if (schema.maximum !== undefined && typeof data === "number" && data > schema.maximum) {
+    errors.push({
+      path,
+      message: `Value must be <= ${schema.maximum}`,
+      keyword: "maximum",
+    });
+  }
+
+  return errors;
+}
+
+// =============================================================================
+// ARTIFACT VALIDATION
+// =============================================================================
+
+/**
+ * Validate an artifact file against its schema
+ */
+function validateArtifact(filePath, schemaId) {
+  const schema = loadSchema(schemaId);
+  if (!schema) {
+    return {
+      valid: false,
+      errors: [{ path: "", message: `Schema ${schemaId} not found`, keyword: "schema" }],
+    };
+  }
+
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (e) {
+    return {
+      valid: false,
+      errors: [{ path: "", message: `Failed to read/parse file: ${e.message}`, keyword: "parse" }],
+    };
+  }
+
+  const errors = validateAgainstSchema(data, schema);
+  return {
+    valid: errors.length === 0,
+    errors,
+    data,
+  };
+}
+
+/**
+ * Validate and write artifact with schema check
+ */
+function writeValidatedArtifact(filePath, data, schemaId) {
+  const schema = loadSchema(schemaId);
+  
+  if (schema) {
+    const errors = validateAgainstSchema(data, schema);
+    if (errors.length > 0) {
+      console.warn(`Warning: Artifact ${filePath} has ${errors.length} schema violations:`);
+      errors.slice(0, 5).forEach(e => console.warn(`  - ${e.path}: ${e.message}`));
+    }
+  }
+
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  
+  return { written: true, path: filePath };
+}
+
+// =============================================================================
+// FINDING GENERATION
+// =============================================================================
+
+/**
+ * Generate stable fingerprint for deduplication
+ */
+function generateFingerprint(parts) {
+  const content = parts.filter(Boolean).join("|");
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+/**
+ * Generate finding ID
+ */
+function generateFindingId(detectorId, fingerprint) {
+  return `F_${detectorId}_${fingerprint.slice(0, 8).toUpperCase()}`;
+}
+
+/**
+ * Generate evidence ID
+ */
+function generateEvidenceId(fingerprint) {
+  return `E_${fingerprint.slice(0, 12).toUpperCase()}`;
+}
+
+/**
+ * Create a spec-compliant finding
+ */
+function createFinding(options = {}) {
+  const {
+    detectorId,
+    severity = "WARN",
+    category = "Routes",
+    scope = "client",
+    title,
+    why,
+    confidence = "medium",
+    evidence = [],
+    repro = null,
+    related = [],
+    proofNode = null,
+    missionType = null,
+    // For fingerprint generation
+    file = null,
+    path: routePath = null,
+    method = null,
+  } = options;
+
+  const fingerprint = generateFingerprint([
+    detectorId,
+    file,
+    routePath,
+    method,
+    title,
+  ]);
+
+  return {
+    id: generateFindingId(detectorId, fingerprint),
+    detectorId,
+    fingerprint: `sha256:${fingerprint}`,
+    severity,
+    category,
+    scope,
+    title,
+    why,
+    confidence,
+    evidence: evidence.map((e, i) => ({
+      id: e.id || generateEvidenceId(fingerprint + i),
+      kind: e.kind || "file",
+      ...e,
+    })),
+    repro,
+    related,
+    proofNode,
+    missionType,
+  };
+}
+
+/**
+ * Create file evidence
+ */
+function createFileEvidence(options = {}) {
+  const { file, lines, snippetHash, reason } = options;
+  const fp = generateFingerprint([file, lines, reason]);
+  
+  return {
+    id: generateEvidenceId(fp),
+    kind: "file",
+    file,
+    lines,
+    snippetHash,
+    reason,
+  };
+}
+
+/**
+ * Create runtime evidence
+ */
+function createRuntimeEvidence(options = {}) {
+  const { url, httpStatus, reason, data } = options;
+  const fp = generateFingerprint([url, httpStatus, reason]);
+  
+  return {
+    id: generateEvidenceId(fp),
+    kind: "request",
+    url,
+    httpStatus,
+    reason,
+    data,
+  };
+}
+
+// =============================================================================
+// SEVERITY POLICY
+// =============================================================================
+
+const SEVERITY_POLICY = {
+  // Route issues
+  ROUTE_MISSING: { default: "BLOCK", withRuntimeProof: "BLOCK" },
+  ROUTE_404: { default: "BLOCK" },
+  ROUTE_405: { default: "WARN" },
+  
+  // Auth issues
+  AUTH_BYPASS: { default: "BLOCK" },
+  AUTH_MISSING: { default: "WARN", criticalPath: "BLOCK" },
+  
+  // Fake success
+  FAKE_SUCCESS: { default: "BLOCK" },
+  SUCCESS_TOAST_NO_CHANGE: { default: "BLOCK" },
+  SUCCESS_BEFORE_REQUEST: { default: "BLOCK" },
+  
+  // Dead UI
+  DEAD_CLICK: { default: "BLOCK" },
+  NO_FEEDBACK: { default: "WARN" },
+  
+  // Contract drift
+  CONTRACT_DRIFT_ROUTE: { default: "WARN", blocking: "BLOCK" },
+  CONTRACT_DRIFT_ENV: { default: "WARN", required: "BLOCK" },
+  CONTRACT_DRIFT_AUTH: { default: "BLOCK" },
+  
+  // Billing
+  STRIPE_WEBHOOK_UNVERIFIED: { default: "BLOCK" },
+  PAID_SURFACE_UNENFORCED: { default: "BLOCK" },
+  
+  // Security
+  OWNER_MODE_BYPASS: { default: "BLOCK" },
+  HARDCODED_SECRET: { default: "BLOCK" },
+};
+
+/**
+ * Get severity based on policy
+ */
+function getSeverity(issueType, context = {}) {
+  const policy = SEVERITY_POLICY[issueType];
+  if (!policy) return "WARN";
+
+  // Check context-specific overrides
+  if (context.hasRuntimeProof && policy.withRuntimeProof) {
+    return policy.withRuntimeProof;
+  }
+  if (context.isCriticalPath && policy.criticalPath) {
+    return policy.criticalPath;
+  }
+  if (context.isBlocking && policy.blocking) {
+    return policy.blocking;
+  }
+  if (context.isRequired && policy.required) {
+    return policy.required;
+  }
+
+  return policy.default;
+}
+
+// =============================================================================
+// EXPORTS
+// =============================================================================
+
+module.exports = {
+  // Schema operations
+  SCHEMAS,
+  loadSchema,
+  validateAgainstSchema,
+  validateArtifact,
+  writeValidatedArtifact,
+  
+  // Finding generation
+  generateFingerprint,
+  generateFindingId,
+  generateEvidenceId,
+  createFinding,
+  createFileEvidence,
+  createRuntimeEvidence,
+  
+  // Severity policy
+  SEVERITY_POLICY,
+  getSeverity,
+};

package/bin/runners/lib/schemas/verdict.schema.json

@@ -0,0 +1,140 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://vibecheck.dev/schemas/verdict.schema.json",
+  "x-schemaVersion": "1.0.0",
+  "title": "Vibecheck Verdict",
+  "description": "Final verdict from ship/checkpoint operations",
+  "type": "object",
+  "required": [
+    "status",
+    "score",
+    "blockers_count",
+    "next_steps",
+    "groups"
+  ],
+  "properties": {
+    "status": {
+      "type": "string",
+      "enum": ["SHIP", "WARN", "BLOCK"],
+      "description": "Final verdict status"
+    },
+    "score": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 100,
+      "description": "Overall health score (0-100)"
+    },
+    "blockers_count": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Number of blocking issues"
+    },
+    "warnings_count": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Number of warning issues"
+    },
+    "info_count": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Number of informational issues"
+    },
+    "next_steps": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Recommended next steps to address issues"
+    },
+    "groups": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/findingGroup"
+      },
+      "description": "Findings grouped by category"
+    },
+    "timestamp": {
+      "type": "string",
+      "format": "date-time",
+      "description": "ISO 8601 timestamp of verdict generation"
+    },
+    "duration_ms": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Analysis duration in milliseconds"
+    },
+    "vibecheck_version": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+",
+      "description": "Vibecheck version that generated this verdict"
+    },
+    "project_fingerprint": {
+      "type": "string",
+      "pattern": "^sha256:[a-f0-9]{64}$",
+      "description": "Hash of project state at analysis time"
+    },
+    "policy": {
+      "type": "object",
+      "properties": {
+        "fail_on_warn": {
+          "type": "boolean",
+          "default": false,
+          "description": "Whether warnings should cause BLOCK status"
+        },
+        "strictness": {
+          "type": "string",
+          "enum": ["chill", "standard", "strict", "paranoid"],
+          "default": "standard"
+        },
+        "required_score": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 100,
+          "description": "Minimum score required to SHIP"
+        }
+      }
+    },
+    "ci_mode": {
+      "type": "boolean",
+      "default": false,
+      "description": "Whether this was run in CI mode"
+    },
+    "exit_code": {
+      "type": "integer",
+      "enum": [0, 1, 2],
+      "description": "Suggested exit code (0=SHIP, 1=WARN, 2=BLOCK)"
+    }
+  },
+  "$defs": {
+    "findingGroup": {
+      "type": "object",
+      "required": ["category", "count", "severity_breakdown"],
+      "properties": {
+        "category": {
+          "type": "string",
+          "description": "Category name"
+        },
+        "count": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Total findings in this category"
+        },
+        "severity_breakdown": {
+          "type": "object",
+          "properties": {
+            "BLOCK": { "type": "integer", "minimum": 0 },
+            "WARN": { "type": "integer", "minimum": 0 },
+            "INFO": { "type": "integer", "minimum": 0 }
+          }
+        },
+        "top_findings": {
+          "type": "array",
+          "items": { "type": "string" },
+          "maxItems": 5,
+          "description": "IDs of top findings in this category"
+        }
+      }
+    }
+  },
+  "additionalProperties": false
+}