@vibecheckai/cli 3.8.0 → 3.9.1

package/bin/runners/lib/engine/enforcement-extractor.js

@@ -1,100 +1,100 @@
-// bin/runners/lib/engine/enforcement-extractor.js
-// Optimized enforcement extraction using RepoIndex
-
-const path = require("path");
-const fs = require("fs");
-
-const ENFORCE_HINTS = [
-  "enforceFeature",
-  "enforceLimit",
-  "getEntitlements",
-  "requirePlan",
-  "requireTier",
-  "requireSubscription",
-  "checkAccess",
-  "entitlements",
-  "plan",
-  "tier",
-  "subscription",
-  "stripe",
-  "credits"
-];
-
-function looksPaidSurface(routePath) {
-  const p = String(routePath || "");
-  return (
-    p.includes("/api/ship") ||
-    p.includes("/api/verdict") ||
-    p.includes("/api/fix") ||
-    p.includes("/api/autopilot") ||
-    p.includes("/api/missions") ||
-    p.includes("/api/pr") ||
-    p.includes("/api/credits") ||
-    p.includes("/api/billing") ||
-    p.includes("/api/stripe") ||
-    p.includes("/api/entitlements")
-  );
-}
-
-/**
- * Check if handler has enforcement signal using RepoIndex
- * @param {import('./repo-index').RepoIndex} index
- * @param {string} handlerRel
- * @returns {{ ok: boolean, hits: string[] }}
- */
-function handlerHasEnforcementSignalV2(index, handlerRel) {
-  const fileAbs = path.join(index.repoRoot, handlerRel);
-  
-  // Try to get content from index first (fast path)
-  let content = index.getContent(fileAbs);
-  
-  // Fall back to direct read if not in index
-  if (!content) {
-    try {
-      content = fs.readFileSync(fileAbs, "utf8");
-    } catch {
-      return { ok: false, hits: [] };
-    }
-  }
-
-  const hits = ENFORCE_HINTS.filter(k => content.includes(k));
-  return { ok: hits.length > 0, hits };
-}
-
-/**
- * Build enforcement truth using RepoIndex (optimized)
- * @param {import('./repo-index').RepoIndex} index
- * @param {Array} serverRoutes
- * @returns {Object}
- */
-function buildEnforcementTruthV2(index, serverRoutes) {
-  const checked = [];
-  const routeList = serverRoutes || [];
-
-  for (const r of routeList) {
-    if (!r.handler) continue;
-    if (!looksPaidSurface(r.path)) continue;
-
-    const res = handlerHasEnforcementSignalV2(index, r.handler);
-    checked.push({
-      method: r.method,
-      path: r.path,
-      handler: r.handler,
-      enforced: res.ok,
-      hits: res.hits
-    });
-  }
-
-  return {
-    checkedCount: checked.length,
-    enforcedCount: checked.filter(x => x.enforced).length,
-    missingCount: checked.filter(x => !x.enforced).length,
-    checks: checked
-  };
-}
-
-module.exports = {
-  buildEnforcementTruthV2,
-  ENFORCE_HINTS,
-  looksPaidSurface,
-};
+// bin/runners/lib/engine/enforcement-extractor.js
+// Optimized enforcement extraction using RepoIndex
+
+const path = require("path");
+const fs = require("fs");
+
+const ENFORCE_HINTS = [
+  "enforceFeature",
+  "enforceLimit",
+  "getEntitlements",
+  "requirePlan",
+  "requireTier",
+  "requireSubscription",
+  "checkAccess",
+  "entitlements",
+  "plan",
+  "tier",
+  "subscription",
+  "stripe",
+  "credits"
+];
+
+function looksPaidSurface(routePath) {
+  const p = String(routePath || "");
+  return (
+    p.includes("/api/ship") ||
+    p.includes("/api/verdict") ||
+    p.includes("/api/fix") ||
+    p.includes("/api/autopilot") ||
+    p.includes("/api/missions") ||
+    p.includes("/api/pr") ||
+    p.includes("/api/credits") ||
+    p.includes("/api/billing") ||
+    p.includes("/api/stripe") ||
+    p.includes("/api/entitlements")
+  );
+}
+
+/**
+ * Check if handler has enforcement signal using RepoIndex
+ * @param {import('./repo-index').RepoIndex} index
+ * @param {string} handlerRel
+ * @returns {{ ok: boolean, hits: string[] }}
+ */
+function handlerHasEnforcementSignalV2(index, handlerRel) {
+  const fileAbs = path.join(index.repoRoot, handlerRel);
+  
+  // Try to get content from index first (fast path)
+  let content = index.getContent(fileAbs);
+  
+  // Fall back to direct read if not in index
+  if (!content) {
+    try {
+      content = fs.readFileSync(fileAbs, "utf8");
+    } catch {
+      return { ok: false, hits: [] };
+    }
+  }
+
+  const hits = ENFORCE_HINTS.filter(k => content.includes(k));
+  return { ok: hits.length > 0, hits };
+}
+
+/**
+ * Build enforcement truth using RepoIndex (optimized)
+ * @param {import('./repo-index').RepoIndex} index
+ * @param {Array} serverRoutes
+ * @returns {Object}
+ */
+function buildEnforcementTruthV2(index, serverRoutes) {
+  const checked = [];
+  const routeList = serverRoutes || [];
+
+  for (const r of routeList) {
+    if (!r.handler) continue;
+    if (!looksPaidSurface(r.path)) continue;
+
+    const res = handlerHasEnforcementSignalV2(index, r.handler);
+    checked.push({
+      method: r.method,
+      path: r.path,
+      handler: r.handler,
+      enforced: res.ok,
+      hits: res.hits
+    });
+  }
+
+  return {
+    checkedCount: checked.length,
+    enforcedCount: checked.filter(x => x.enforced).length,
+    missingCount: checked.filter(x => !x.enforced).length,
+    checks: checked
+  };
+}
+
+module.exports = {
+  buildEnforcementTruthV2,
+  ENFORCE_HINTS,
+  looksPaidSurface,
+};

package/bin/runners/lib/engine/env-extractor.js

@@ -1,207 +1,207 @@
-// bin/runners/lib/engine/env-extractor.js
-// Optimized env var extraction using RepoIndex
-
-const path = require("path");
-const fs = require("fs");
-const crypto = require("crypto");
-const traverse = require("@babel/traverse").default;
-const t = require("@babel/types");
-const { globalASTCache } = require("./ast-cache");
-
-function sha256(text) {
-  return "sha256:" + crypto.createHash("sha256").update(text).digest("hex");
-}
-
-function isEnvName(s) {
-  return typeof s === "string" && /^[A-Z0-9_]+$/.test(s);
-}
-
-function extractEnvFromMemberExpr(node) {
-  if (!t.isMemberExpression(node)) return null;
-
-  // process.env.NAME
-  if (t.isMemberExpression(node.object) &&
-      t.isIdentifier(node.object.object, { name: "process" }) &&
-      t.isIdentifier(node.object.property, { name: "env" }) &&
-      t.isIdentifier(node.property)) {
-    return node.property.name;
-  }
-
-  // process.env["NAME"]
-  if (t.isMemberExpression(node.object) &&
-      t.isIdentifier(node.object.object, { name: "process" }) &&
-      t.isIdentifier(node.object.property, { name: "env" }) &&
-      t.isStringLiteral(node.property)) {
-    return node.property.value;
-  }
-
-  // import.meta.env.NAME
-  if (t.isMemberExpression(node.object) &&
-      t.isMemberExpression(node.object.object) &&
-      t.isIdentifier(node.object.object.object, { name: "import" }) &&
-      t.isIdentifier(node.object.object.property, { name: "meta" }) &&
-      t.isIdentifier(node.object.property, { name: "env" }) &&
-      t.isIdentifier(node.property)) {
-    return node.property.name;
-  }
-
-  return null;
-}
-
-function detectDefaultSignals(parentPath) {
-  const p = parentPath?.parentPath;
-  if (!p) return { hasDefault: false };
-
-  if (p.isLogicalExpression() && (p.node.operator === "||" || p.node.operator === "??")) {
-    return { hasDefault: true };
-  }
-  if (p.isConditionalExpression()) return { hasDefault: true };
-  if (p.isAssignmentExpression() && p.node.operator === "||=") return { hasDefault: true };
-  return { hasDefault: false };
-}
-
-function evidenceFromContent(content, fileRel, loc, reason) {
-  if (!loc || !content) return null;
-  const lines = content.split(/\r?\n/);
-  const start = Math.max(1, loc.start?.line || 1);
-  const end = Math.max(start, loc.end?.line || start);
-  const snippet = lines.slice(start - 1, end).join("\n");
-  return {
-    id: `ev_${crypto.randomBytes(4).toString("hex")}`,
-    file: fileRel,
-    lines: `${start}-${end}`,
-    snippetHash: sha256(snippet),
-    reason
-  };
-}
-
-function parseDotEnvLike(content) {
-  const out = new Set();
-  const lines = content.split(/\r?\n/);
-  for (const raw of lines) {
-    const line = raw.trim();
-    if (!line || line.startsWith("#")) continue;
-    const l = line.startsWith("export ") ? line.slice(7).trim() : line;
-    const eq = l.indexOf("=");
-    if (eq <= 0) continue;
-    const key = l.slice(0, eq).trim();
-    if (isEnvName(key)) out.add(key);
-  }
-  return out;
-}
-
-/**
- * Extract env var usage using RepoIndex
- * @param {import('./repo-index').RepoIndex} index
- * @param {Object} stats
- * @returns {Object} - Map of env var name to usage info
- */
-function extractEnvUsage(index, stats) {
-  // Use token prefilter - only scan files that reference process.env or import.meta.env
-  const candidateAbs = index.getByAnyToken(["process.env", "import.meta.env"]);
-  
-  // Filter to JS/TS files
-  const jsExtensions = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
-  const files = candidateAbs.filter(abs => {
-    const ext = path.extname(abs).toLowerCase();
-    return jsExtensions.has(ext);
-  });
-
-  const usageMap = {};
-
-  for (const fileAbs of files) {
-    const fileRel = index.relPath(fileAbs);
-    const content = index.getContent(fileAbs);
-    if (!content) continue;
-
-    const { ast, error } = globalASTCache.parse(content, fileAbs);
-    if (error || !ast) {
-      stats.parseErrors++;
-      continue;
-    }
-
-    try {
-      traverse(ast, {
-        MemberExpression(p) {
-          const name = extractEnvFromMemberExpr(p.node);
-          if (!name || !isEnvName(name)) return;
-
-          usageMap[name] = usageMap[name] || { name, references: [], signals: { hasDefault: false } };
-
-          const ev = evidenceFromContent(content, fileRel, p.node.loc, `Env usage: ${name}`);
-          if (ev) usageMap[name].references.push(ev);
-
-          const sig = detectDefaultSignals(p);
-          if (sig.hasDefault) usageMap[name].signals.hasDefault = true;
-        }
-      });
-    } catch {
-      stats.parseErrors++;
-    }
-  }
-
-  return usageMap;
-}
-
-/**
- * Extract declared env vars from .env files
- * @param {string} repoRoot
- * @returns {{ declared: string[], sources: string[] }}
- */
-function extractEnvDeclared(repoRoot) {
-  const candidates = [
-    ".env.example", ".env.template", ".env.sample",
-    ".env.local.example", ".env.development.example",
-    ".env"
-  ];
-
-  const declared = new Set();
-  const sources = [];
-
-  for (const rel of candidates) {
-    const abs = path.join(repoRoot, rel);
-    try {
-      if (!fs.existsSync(abs)) continue;
-      const content = fs.readFileSync(abs, "utf8");
-      const keys = parseDotEnvLike(content);
-      if (keys.size) {
-        for (const k of keys) declared.add(k);
-        sources.push(rel);
-      }
-    } catch {}
-  }
-
-  return { declared: Array.from(declared).sort(), sources };
-}
-
-/**
- * Build env truth using RepoIndex (optimized)
- * @param {import('./repo-index').RepoIndex} index
- * @param {Object} stats
- * @returns {Object}
- */
-function buildEnvTruthV2(index, stats) {
-  const usageMap = extractEnvUsage(index, stats);
-  const declared = extractEnvDeclared(index.repoRoot);
-
-  const used = Object.values(usageMap).sort((a, b) => a.name.localeCompare(b.name));
-
-  const vars = used.map(u => ({
-    name: u.name,
-    required: !u.signals?.hasDefault,
-    references: u.references || [],
-    notes: u.signals?.hasDefault ? "Has default/fallback usage signal" : ""
-  }));
-
-  return {
-    vars,
-    declared: declared.declared,
-    declaredSources: declared.sources
-  };
-}
-
-module.exports = {
-  extractEnvUsage,
-  extractEnvDeclared,
-  buildEnvTruthV2,
-};
+// bin/runners/lib/engine/env-extractor.js
+// Optimized env var extraction using RepoIndex
+
+const path = require("path");
+const fs = require("fs");
+const crypto = require("crypto");
+const traverse = require("@babel/traverse").default;
+const t = require("@babel/types");
+const { globalASTCache } = require("./ast-cache");
+
+function sha256(text) {
+  return "sha256:" + crypto.createHash("sha256").update(text).digest("hex");
+}
+
+function isEnvName(s) {
+  return typeof s === "string" && /^[A-Z0-9_]+$/.test(s);
+}
+
+function extractEnvFromMemberExpr(node) {
+  if (!t.isMemberExpression(node)) return null;
+
+  // process.env.NAME
+  if (t.isMemberExpression(node.object) &&
+      t.isIdentifier(node.object.object, { name: "process" }) &&
+      t.isIdentifier(node.object.property, { name: "env" }) &&
+      t.isIdentifier(node.property)) {
+    return node.property.name;
+  }
+
+  // process.env["NAME"]
+  if (t.isMemberExpression(node.object) &&
+      t.isIdentifier(node.object.object, { name: "process" }) &&
+      t.isIdentifier(node.object.property, { name: "env" }) &&
+      t.isStringLiteral(node.property)) {
+    return node.property.value;
+  }
+
+  // import.meta.env.NAME
+  if (t.isMemberExpression(node.object) &&
+      t.isMemberExpression(node.object.object) &&
+      t.isIdentifier(node.object.object.object, { name: "import" }) &&
+      t.isIdentifier(node.object.object.property, { name: "meta" }) &&
+      t.isIdentifier(node.object.property, { name: "env" }) &&
+      t.isIdentifier(node.property)) {
+    return node.property.name;
+  }
+
+  return null;
+}
+
+function detectDefaultSignals(parentPath) {
+  const p = parentPath?.parentPath;
+  if (!p) return { hasDefault: false };
+
+  if (p.isLogicalExpression() && (p.node.operator === "||" || p.node.operator === "??")) {
+    return { hasDefault: true };
+  }
+  if (p.isConditionalExpression()) return { hasDefault: true };
+  if (p.isAssignmentExpression() && p.node.operator === "||=") return { hasDefault: true };
+  return { hasDefault: false };
+}
+
+function evidenceFromContent(content, fileRel, loc, reason) {
+  if (!loc || !content) return null;
+  const lines = content.split(/\r?\n/);
+  const start = Math.max(1, loc.start?.line || 1);
+  const end = Math.max(start, loc.end?.line || start);
+  const snippet = lines.slice(start - 1, end).join("\n");
+  return {
+    id: `ev_${crypto.randomBytes(4).toString("hex")}`,
+    file: fileRel,
+    lines: `${start}-${end}`,
+    snippetHash: sha256(snippet),
+    reason
+  };
+}
+
+function parseDotEnvLike(content) {
+  const out = new Set();
+  const lines = content.split(/\r?\n/);
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const l = line.startsWith("export ") ? line.slice(7).trim() : line;
+    const eq = l.indexOf("=");
+    if (eq <= 0) continue;
+    const key = l.slice(0, eq).trim();
+    if (isEnvName(key)) out.add(key);
+  }
+  return out;
+}
+
+/**
+ * Extract env var usage using RepoIndex
+ * @param {import('./repo-index').RepoIndex} index
+ * @param {Object} stats
+ * @returns {Object} - Map of env var name to usage info
+ */
+function extractEnvUsage(index, stats) {
+  // Use token prefilter - only scan files that reference process.env or import.meta.env
+  const candidateAbs = index.getByAnyToken(["process.env", "import.meta.env"]);
+  
+  // Filter to JS/TS files
+  const jsExtensions = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+  const files = candidateAbs.filter(abs => {
+    const ext = path.extname(abs).toLowerCase();
+    return jsExtensions.has(ext);
+  });
+
+  const usageMap = {};
+
+  for (const fileAbs of files) {
+    const fileRel = index.relPath(fileAbs);
+    const content = index.getContent(fileAbs);
+    if (!content) continue;
+
+    const { ast, error } = globalASTCache.parse(content, fileAbs);
+    if (error || !ast) {
+      stats.parseErrors++;
+      continue;
+    }
+
+    try {
+      traverse(ast, {
+        MemberExpression(p) {
+          const name = extractEnvFromMemberExpr(p.node);
+          if (!name || !isEnvName(name)) return;
+
+          usageMap[name] = usageMap[name] || { name, references: [], signals: { hasDefault: false } };
+
+          const ev = evidenceFromContent(content, fileRel, p.node.loc, `Env usage: ${name}`);
+          if (ev) usageMap[name].references.push(ev);
+
+          const sig = detectDefaultSignals(p);
+          if (sig.hasDefault) usageMap[name].signals.hasDefault = true;
+        }
+      });
+    } catch {
+      stats.parseErrors++;
+    }
+  }
+
+  return usageMap;
+}
+
+/**
+ * Extract declared env vars from .env files
+ * @param {string} repoRoot
+ * @returns {{ declared: string[], sources: string[] }}
+ */
+function extractEnvDeclared(repoRoot) {
+  const candidates = [
+    ".env.example", ".env.template", ".env.sample",
+    ".env.local.example", ".env.development.example",
+    ".env"
+  ];
+
+  const declared = new Set();
+  const sources = [];
+
+  for (const rel of candidates) {
+    const abs = path.join(repoRoot, rel);
+    try {
+      if (!fs.existsSync(abs)) continue;
+      const content = fs.readFileSync(abs, "utf8");
+      const keys = parseDotEnvLike(content);
+      if (keys.size) {
+        for (const k of keys) declared.add(k);
+        sources.push(rel);
+      }
+    } catch {}
+  }
+
+  return { declared: Array.from(declared).sort(), sources };
+}
+
+/**
+ * Build env truth using RepoIndex (optimized)
+ * @param {import('./repo-index').RepoIndex} index
+ * @param {Object} stats
+ * @returns {Object}
+ */
+function buildEnvTruthV2(index, stats) {
+  const usageMap = extractEnvUsage(index, stats);
+  const declared = extractEnvDeclared(index.repoRoot);
+
+  const used = Object.values(usageMap).sort((a, b) => a.name.localeCompare(b.name));
+
+  const vars = used.map(u => ({
+    name: u.name,
+    required: !u.signals?.hasDefault,
+    references: u.references || [],
+    notes: u.signals?.hasDefault ? "Has default/fallback usage signal" : ""
+  }));
+
+  return {
+    vars,
+    declared: declared.declared,
+    declaredSources: declared.sources
+  };
+}
+
+module.exports = {
+  extractEnvUsage,
+  extractEnvDeclared,
+  buildEnvTruthV2,
+};