@vibecheckai/cli 3.2.5 → 3.3.0

package/bin/runners/lib/global-flags.js

@@ -128,6 +128,41 @@ function shouldShowBanner(flags = {}) {
   return true;
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// OUTPUT SUPPRESSION CHECK
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Check if non-essential output should be suppressed
+ * Use this before any console output that isn't errors or JSON
+ * 
+ * @param {object} flags - Parsed flags object
+ * @returns {boolean} true if output should be suppressed
+ */
+function shouldSuppressOutput(flags = {}) {
+  // Suppress if quiet or CI mode
+  if (flags.quiet || flags.ci) return true;
+  
+  // Suppress if JSON mode (only structured output allowed)
+  if (flags.json) return true;
+  
+  // Check environment
+  if (process.env.VIBECHECK_QUIET === "true") return true;
+  
+  return false;
+}
+
+/**
+ * Check if we're in JSON output mode
+ * Use this to decide between pretty output and structured JSON
+ * 
+ * @param {object} flags - Parsed flags object  
+ * @returns {boolean} true if JSON output is requested
+ */
+function isJsonMode(flags = {}) {
+  return flags.json === true;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // CI DETECTION
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -204,6 +239,8 @@ function loadConfig(flags = {}) {
 module.exports = {
   parseGlobalFlags,
   shouldShowBanner,
+  shouldSuppressOutput,
+  isJsonMode,
   isCI,
   loadConfig,
   lazy,

package/bin/runners/lib/graph/graph-builder.js

@@ -1,265 +1,265 @@
-/**
- * Graph Builder
- * Builds the complete ProofGraph from static and runtime edges
- */
-
-"use strict";
-
-const crypto = require("crypto");
-
-function sha256(text) {
-  return crypto.createHash("sha256").update(text).digest("hex").slice(0, 16);
-}
-
-/**
- * Build ProofGraph from extracted nodes and edges
- */
-function buildProofGraph({ nodes, edges, runtimeEdges = [], meta = {} }) {
-  const graph = {
-    meta: {
-      version: "1.0.0",
-      generatedAt: new Date().toISOString(),
-      commit: meta.commit || process.env.VIBECHECK_COMMIT_SHA || "unknown",
-      ...meta
-    },
-    nodes: [],
-    edges: [],
-    brokenEdges: [],
-    coverage: {
-      static: 0,
-      runtime: 0,
-      total: 0
-    }
-  };
-
-  // Dedupe and add nodes
-  const nodeMap = new Map();
-  for (const n of nodes) {
-    if (!nodeMap.has(n.id)) {
-      nodeMap.set(n.id, n);
-    }
-  }
-  graph.nodes = Array.from(nodeMap.values());
-
-  // Process edges, separate broken ones
-  const brokenEdges = [];
-  const validEdges = [];
-
-  for (const edge of edges) {
-    if (edge.broken) {
-      brokenEdges.push({
-        edge: {
-          id: edge.id,
-          from: edge.from,
-          to: edge.to,
-          type: edge.type,
-          confidence: edge.confidence || "low"
-        },
-        reason: edge.brokenReason || "Edge target not found",
-        severity: determineSeverity(edge),
-        route: edge.toRoute || null
-      });
-    } else {
-      validEdges.push({
-        id: edge.id,
-        from: edge.from,
-        to: edge.to,
-        type: edge.type,
-        confidence: edge.confidence || "med",
-        verifiedAt: "static"
-      });
-    }
-  }
-
-  // Add runtime edges
-  for (const re of runtimeEdges) {
-    const existing = validEdges.find(e => e.from === re.from && e.to === re.to);
-    if (existing) {
-      existing.verifiedAt = "runtime";
-      existing.runtimeData = re.data;
-    } else {
-      validEdges.push({
-        id: re.id || `runtime_${sha256(re.from + re.to)}`,
-        from: re.from,
-        to: re.to,
-        type: re.type || "runtime",
-        confidence: "high",
-        verifiedAt: "runtime",
-        runtimeData: re.data
-      });
-    }
-  }
-
-  graph.edges = validEdges;
-  graph.brokenEdges = brokenEdges;
-
-  // Calculate coverage
-  const totalPossibleEdges = graph.edges.length + graph.brokenEdges.length;
-  graph.coverage = {
-    static: graph.edges.filter(e => e.verifiedAt === "static").length,
-    runtime: graph.edges.filter(e => e.verifiedAt === "runtime").length,
-    broken: graph.brokenEdges.length,
-    total: totalPossibleEdges,
-    percent: totalPossibleEdges > 0 
-      ? Math.round((graph.edges.length / totalPossibleEdges) * 100) 
-      : 100
-  };
-
-  return graph;
-}
-
-function determineSeverity(edge) {
-  // Missing routes are always BLOCK
-  if (edge.toRoute) return "BLOCK";
-  
-  // Unresolved function calls are WARN
-  if (edge.to?.startsWith("unresolved_")) return "WARN";
-  
-  return "WARN";
-}
-
-/**
- * Merge runtime verification results into graph
- */
-function mergeRuntimeResults(graph, runtimeResults) {
-  const updatedGraph = { ...graph };
-  
-  for (const result of runtimeResults) {
-    // Find edge that matches this runtime result
-    const edge = updatedGraph.edges.find(e => 
-      e.to?.includes(result.path) || 
-      (e.type === "calls_route" && e.toRoute?.path === result.path)
-    );
-
-    if (edge) {
-      edge.verifiedAt = "runtime";
-      edge.runtimeData = {
-        status: result.status,
-        latencyMs: result.latencyMs,
-        error: result.error
-      };
-
-      // Check for runtime failures
-      if (result.status >= 400) {
-        const brokenEdge = {
-          edge: { ...edge },
-          reason: `Route returns ${result.status} at runtime`,
-          severity: result.status >= 500 ? "BLOCK" : "WARN",
-          runtimeData: edge.runtimeData
-        };
-        
-        // Move to broken edges
-        updatedGraph.brokenEdges.push(brokenEdge);
-        updatedGraph.edges = updatedGraph.edges.filter(e => e.id !== edge.id);
-      }
-    }
-  }
-
-  // Recalculate coverage
-  const totalPossibleEdges = updatedGraph.edges.length + updatedGraph.brokenEdges.length;
-  updatedGraph.coverage = {
-    static: updatedGraph.edges.filter(e => e.verifiedAt === "static").length,
-    runtime: updatedGraph.edges.filter(e => e.verifiedAt === "runtime").length,
-    broken: updatedGraph.brokenEdges.length,
-    total: totalPossibleEdges,
-    percent: totalPossibleEdges > 0 
-      ? Math.round((updatedGraph.edges.length / totalPossibleEdges) * 100) 
-      : 100
-  };
-
-  return updatedGraph;
-}
-
-/**
- * Compute graph diff between two graphs
- */
-function computeGraphDiff(before, after) {
-  const diff = {
-    nodesAdded: [],
-    nodesRemoved: [],
-    edgesAdded: [],
-    edgesRemoved: [],
-    edgesFixed: [],
-    edgesBroken: []
-  };
-
-  const beforeNodeIds = new Set(before.nodes.map(n => n.id));
-  const afterNodeIds = new Set(after.nodes.map(n => n.id));
-
-  for (const n of after.nodes) {
-    if (!beforeNodeIds.has(n.id)) diff.nodesAdded.push(n);
-  }
-  for (const n of before.nodes) {
-    if (!afterNodeIds.has(n.id)) diff.nodesRemoved.push(n);
-  }
-
-  const beforeEdgeIds = new Set(before.edges.map(e => e.id));
-  const afterEdgeIds = new Set(after.edges.map(e => e.id));
-  const beforeBrokenIds = new Set(before.brokenEdges.map(e => e.edge.id));
-  const afterBrokenIds = new Set(after.brokenEdges.map(e => e.edge.id));
-
-  for (const e of after.edges) {
-    if (!beforeEdgeIds.has(e.id)) {
-      if (beforeBrokenIds.has(e.id)) {
-        diff.edgesFixed.push(e);
-      } else {
-        diff.edgesAdded.push(e);
-      }
-    }
-  }
-
-  for (const e of before.edges) {
-    if (!afterEdgeIds.has(e.id)) {
-      if (afterBrokenIds.has(e.id)) {
-        diff.edgesBroken.push(e);
-      } else {
-        diff.edgesRemoved.push(e);
-      }
-    }
-  }
-
-  return diff;
-}
-
-/**
- * Get findings from broken edges
- */
-function getFindingsFromGraph(graph) {
-  const findings = [];
-
-  for (const broken of graph.brokenEdges) {
-    const finding = {
-      id: `GRAPH_${broken.edge.id}`,
-      severity: broken.severity,
-      category: "BrokenEdge",
-      title: broken.reason,
-      evidence: [],
-      graphEdge: broken.edge
-    };
-
-    if (broken.route) {
-      finding.title = `Route ${broken.route.method} ${broken.route.path} referenced but doesn't exist`;
-      finding.category = "MissingRoute";
-    }
-
-    if (broken.runtimeData) {
-      finding.title = `Route returns ${broken.runtimeData.status} at runtime`;
-      finding.category = "RuntimeFailure";
-      if (broken.runtimeData.status === 401) {
-        finding.title = "UI shows success but server returned 401 (auth required)";
-        finding.category = "CausalContradiction";
-      }
-    }
-
-    findings.push(finding);
-  }
-
-  return findings;
-}
-
-module.exports = {
-  buildProofGraph,
-  mergeRuntimeResults,
-  computeGraphDiff,
-  getFindingsFromGraph
-};
+/**
+ * Graph Builder
+ * Builds the complete ProofGraph from static and runtime edges
+ */
+
+"use strict";
+
+const crypto = require("crypto");
+
+function sha256(text) {
+  return crypto.createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+
+/**
+ * Build ProofGraph from extracted nodes and edges
+ */
+function buildProofGraph({ nodes, edges, runtimeEdges = [], meta = {} }) {
+  const graph = {
+    meta: {
+      version: "1.0.0",
+      generatedAt: new Date().toISOString(),
+      commit: meta.commit || process.env.VIBECHECK_COMMIT_SHA || "unknown",
+      ...meta
+    },
+    nodes: [],
+    edges: [],
+    brokenEdges: [],
+    coverage: {
+      static: 0,
+      runtime: 0,
+      total: 0
+    }
+  };
+
+  // Dedupe and add nodes
+  const nodeMap = new Map();
+  for (const n of nodes) {
+    if (!nodeMap.has(n.id)) {
+      nodeMap.set(n.id, n);
+    }
+  }
+  graph.nodes = Array.from(nodeMap.values());
+
+  // Process edges, separate broken ones
+  const brokenEdges = [];
+  const validEdges = [];
+
+  for (const edge of edges) {
+    if (edge.broken) {
+      brokenEdges.push({
+        edge: {
+          id: edge.id,
+          from: edge.from,
+          to: edge.to,
+          type: edge.type,
+          confidence: edge.confidence || "low"
+        },
+        reason: edge.brokenReason || "Edge target not found",
+        severity: determineSeverity(edge),
+        route: edge.toRoute || null
+      });
+    } else {
+      validEdges.push({
+        id: edge.id,
+        from: edge.from,
+        to: edge.to,
+        type: edge.type,
+        confidence: edge.confidence || "med",
+        verifiedAt: "static"
+      });
+    }
+  }
+
+  // Add runtime edges
+  for (const re of runtimeEdges) {
+    const existing = validEdges.find(e => e.from === re.from && e.to === re.to);
+    if (existing) {
+      existing.verifiedAt = "runtime";
+      existing.runtimeData = re.data;
+    } else {
+      validEdges.push({
+        id: re.id || `runtime_${sha256(re.from + re.to)}`,
+        from: re.from,
+        to: re.to,
+        type: re.type || "runtime",
+        confidence: "high",
+        verifiedAt: "runtime",
+        runtimeData: re.data
+      });
+    }
+  }
+
+  graph.edges = validEdges;
+  graph.brokenEdges = brokenEdges;
+
+  // Calculate coverage
+  const totalPossibleEdges = graph.edges.length + graph.brokenEdges.length;
+  graph.coverage = {
+    static: graph.edges.filter(e => e.verifiedAt === "static").length,
+    runtime: graph.edges.filter(e => e.verifiedAt === "runtime").length,
+    broken: graph.brokenEdges.length,
+    total: totalPossibleEdges,
+    percent: totalPossibleEdges > 0 
+      ? Math.round((graph.edges.length / totalPossibleEdges) * 100) 
+      : 100
+  };
+
+  return graph;
+}
+
+function determineSeverity(edge) {
+  // Missing routes are always BLOCK
+  if (edge.toRoute) return "BLOCK";
+  
+  // Unresolved function calls are WARN
+  if (edge.to?.startsWith("unresolved_")) return "WARN";
+  
+  return "WARN";
+}
+
+/**
+ * Merge runtime verification results into graph
+ */
+function mergeRuntimeResults(graph, runtimeResults) {
+  const updatedGraph = { ...graph };
+  
+  for (const result of runtimeResults) {
+    // Find edge that matches this runtime result
+    const edge = updatedGraph.edges.find(e => 
+      e.to?.includes(result.path) || 
+      (e.type === "calls_route" && e.toRoute?.path === result.path)
+    );
+
+    if (edge) {
+      edge.verifiedAt = "runtime";
+      edge.runtimeData = {
+        status: result.status,
+        latencyMs: result.latencyMs,
+        error: result.error
+      };
+
+      // Check for runtime failures
+      if (result.status >= 400) {
+        const brokenEdge = {
+          edge: { ...edge },
+          reason: `Route returns ${result.status} at runtime`,
+          severity: result.status >= 500 ? "BLOCK" : "WARN",
+          runtimeData: edge.runtimeData
+        };
+        
+        // Move to broken edges
+        updatedGraph.brokenEdges.push(brokenEdge);
+        updatedGraph.edges = updatedGraph.edges.filter(e => e.id !== edge.id);
+      }
+    }
+  }
+
+  // Recalculate coverage
+  const totalPossibleEdges = updatedGraph.edges.length + updatedGraph.brokenEdges.length;
+  updatedGraph.coverage = {
+    static: updatedGraph.edges.filter(e => e.verifiedAt === "static").length,
+    runtime: updatedGraph.edges.filter(e => e.verifiedAt === "runtime").length,
+    broken: updatedGraph.brokenEdges.length,
+    total: totalPossibleEdges,
+    percent: totalPossibleEdges > 0 
+      ? Math.round((updatedGraph.edges.length / totalPossibleEdges) * 100) 
+      : 100
+  };
+
+  return updatedGraph;
+}
+
+/**
+ * Compute graph diff between two graphs
+ */
+function computeGraphDiff(before, after) {
+  const diff = {
+    nodesAdded: [],
+    nodesRemoved: [],
+    edgesAdded: [],
+    edgesRemoved: [],
+    edgesFixed: [],
+    edgesBroken: []
+  };
+
+  const beforeNodeIds = new Set(before.nodes.map(n => n.id));
+  const afterNodeIds = new Set(after.nodes.map(n => n.id));
+
+  for (const n of after.nodes) {
+    if (!beforeNodeIds.has(n.id)) diff.nodesAdded.push(n);
+  }
+  for (const n of before.nodes) {
+    if (!afterNodeIds.has(n.id)) diff.nodesRemoved.push(n);
+  }
+
+  const beforeEdgeIds = new Set(before.edges.map(e => e.id));
+  const afterEdgeIds = new Set(after.edges.map(e => e.id));
+  const beforeBrokenIds = new Set(before.brokenEdges.map(e => e.edge.id));
+  const afterBrokenIds = new Set(after.brokenEdges.map(e => e.edge.id));
+
+  for (const e of after.edges) {
+    if (!beforeEdgeIds.has(e.id)) {
+      if (beforeBrokenIds.has(e.id)) {
+        diff.edgesFixed.push(e);
+      } else {
+        diff.edgesAdded.push(e);
+      }
+    }
+  }
+
+  for (const e of before.edges) {
+    if (!afterEdgeIds.has(e.id)) {
+      if (afterBrokenIds.has(e.id)) {
+        diff.edgesBroken.push(e);
+      } else {
+        diff.edgesRemoved.push(e);
+      }
+    }
+  }
+
+  return diff;
+}
+
+/**
+ * Get findings from broken edges
+ */
+function getFindingsFromGraph(graph) {
+  const findings = [];
+
+  for (const broken of graph.brokenEdges) {
+    const finding = {
+      id: `GRAPH_${broken.edge.id}`,
+      severity: broken.severity,
+      category: "BrokenEdge",
+      title: broken.reason,
+      evidence: [],
+      graphEdge: broken.edge
+    };
+
+    if (broken.route) {
+      finding.title = `Route ${broken.route.method} ${broken.route.path} referenced but doesn't exist`;
+      finding.category = "MissingRoute";
+    }
+
+    if (broken.runtimeData) {
+      finding.title = `Route returns ${broken.runtimeData.status} at runtime`;
+      finding.category = "RuntimeFailure";
+      if (broken.runtimeData.status === 401) {
+        finding.title = "UI shows success but server returned 401 (auth required)";
+        finding.category = "CausalContradiction";
+      }
+    }
+
+    findings.push(finding);
+  }
+
+  return findings;
+}
+
+module.exports = {
+  buildProofGraph,
+  mergeRuntimeResults,
+  computeGraphDiff,
+  getFindingsFromGraph
+};