@vibecheckai/cli 3.2.5 → 3.3.0

package/bin/runners/lib/env-template.js

@@ -1,66 +1,66 @@
-// bin/runners/lib/env-template.js
-const fs = require("fs");
-const path = require("path");
-
-function ensureDir(p) {
-  fs.mkdirSync(p, { recursive: true });
-}
-
-function pickEnvTemplatePath(root) {
-  const candidates = [".env.template", ".env.example", ".env.sample"];
-  for (const c of candidates) {
-    const abs = path.join(root, c);
-    if (fs.existsSync(abs)) return c;
-  }
-  return ".env.template";
-}
-
-function normalizeEnvName(n) {
-  return String(n || "").trim();
-}
-
-function parseDeclaredEnvFromText(text) {
-  const declared = new Set();
-  const lines = String(text || "").split(/\r?\n/);
-  for (const l of lines) {
-    if (!l || l.trim().startsWith("#")) continue;
-    const m = l.match(/^([A-Z0-9_]+)\s*=/);
-    if (m) declared.add(m[1]);
-  }
-  return declared;
-}
-
-function writeEnvTemplateFromTruthpack(root, truthpack) {
-  const outRel = pickEnvTemplatePath(root);
-  const outAbs = path.join(root, outRel);
-
-  const used = new Set((truthpack?.env?.vars || []).map(normalizeEnvName).filter(Boolean));
-
-  let existingText = "";
-  if (fs.existsSync(outAbs)) existingText = fs.readFileSync(outAbs, "utf8");
-
-  const declared = parseDeclaredEnvFromText(existingText);
-  const missing = Array.from(used).filter((x) => !declared.has(x)).sort();
-
-  if (!missing.length && fs.existsSync(outAbs)) {
-    return { outRel, wrote: false, added: [] };
-  }
-
-  const header =
-`# vibecheck env template
-# This file is generated/extended from REAL env usage found in your code.
-# Fill values in your real .env (never commit secrets).
-
-`;
-
-  const additions = missing.map((k) => `${k}=\n`).join("");
-
-  const nextText = (existingText.trim().length ? existingText.trimEnd() + "\n\n" : header) + additions;
-
-  ensureDir(path.dirname(outAbs));
-  fs.writeFileSync(outAbs, nextText, "utf8");
-
-  return { outRel, wrote: true, added: missing };
-}
-
-module.exports = { writeEnvTemplateFromTruthpack };
+// bin/runners/lib/env-template.js
+const fs = require("fs");
+const path = require("path");
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function pickEnvTemplatePath(root) {
+  const candidates = [".env.template", ".env.example", ".env.sample"];
+  for (const c of candidates) {
+    const abs = path.join(root, c);
+    if (fs.existsSync(abs)) return c;
+  }
+  return ".env.template";
+}
+
+function normalizeEnvName(n) {
+  return String(n || "").trim();
+}
+
+function parseDeclaredEnvFromText(text) {
+  const declared = new Set();
+  const lines = String(text || "").split(/\r?\n/);
+  for (const l of lines) {
+    if (!l || l.trim().startsWith("#")) continue;
+    const m = l.match(/^([A-Z0-9_]+)\s*=/);
+    if (m) declared.add(m[1]);
+  }
+  return declared;
+}
+
+function writeEnvTemplateFromTruthpack(root, truthpack) {
+  const outRel = pickEnvTemplatePath(root);
+  const outAbs = path.join(root, outRel);
+
+  const used = new Set((truthpack?.env?.vars || []).map(normalizeEnvName).filter(Boolean));
+
+  let existingText = "";
+  if (fs.existsSync(outAbs)) existingText = fs.readFileSync(outAbs, "utf8");
+
+  const declared = parseDeclaredEnvFromText(existingText);
+  const missing = Array.from(used).filter((x) => !declared.has(x)).sort();
+
+  if (!missing.length && fs.existsSync(outAbs)) {
+    return { outRel, wrote: false, added: [] };
+  }
+
+  const header =
+`# vibecheck env template
+# This file is generated/extended from REAL env usage found in your code.
+# Fill values in your real .env (never commit secrets).
+
+`;
+
+  const additions = missing.map((k) => `${k}=\n`).join("");
+
+  const nextText = (existingText.trim().length ? existingText.trimEnd() + "\n\n" : header) + additions;
+
+  ensureDir(path.dirname(outAbs));
+  fs.writeFileSync(outAbs, nextText, "utf8");
+
+  return { outRel, wrote: true, added: missing };
+}
+
+module.exports = { writeEnvTemplateFromTruthpack };

package/bin/runners/lib/env.js

@@ -1,189 +1,189 @@
-// bin/runners/lib/env.js
-const fg = require("fast-glob");
-const fs = require("fs");
-const path = require("path");
-const parser = require("@babel/parser");
-const traverse = require("@babel/traverse").default;
-const t = require("@babel/types");
-const crypto = require("crypto");
-
-function sha256(text) {
-  return "sha256:" + crypto.createHash("sha256").update(text).digest("hex");
-}
-
-function parseFile(code) {
-  return parser.parse(code, { sourceType: "unambiguous", plugins: ["typescript", "jsx"] });
-}
-
-function safeRead(fileAbs) {
-  return fs.readFileSync(fileAbs, "utf8");
-}
-
-function evidenceFromLoc({ fileAbs, fileRel, loc, reason }) {
-  if (!loc) return null;
-  const lines = safeRead(fileAbs).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 mergeEvidenceMap(map, name, ev) {
-  map[name] = map[name] || { name, references: [], signals: { hasDefault: false } };
-  if (ev) map[name].references.push(ev);
-}
-
-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 };
-}
-
-async function resolveEnvUsage(repoRoot) {
-  const files = await fg(["**/*.{ts,tsx,js,jsx}"], {
-    cwd: repoRoot,
-    absolute: true,
-    ignore: ["**/node_modules/**","**/.next/**","**/dist/**","**/build/**"]
-  });
-
-  const usageMap = {};
-
-  for (const fileAbs of files) {
-    const fileRel = path.relative(repoRoot, fileAbs).replace(/\\/g, "/");
-    const code = safeRead(fileAbs);
-
-    let ast;
-    try { ast = parseFile(code); } catch { continue; }
-
-    traverse(ast, {
-      MemberExpression(p) {
-        const name = extractEnvFromMemberExpr(p.node);
-        if (!name || !isEnvName(name)) return;
-
-        const ev = evidenceFromLoc({
-          fileAbs,
-          fileRel,
-          loc: p.node.loc,
-          reason: `Env usage: ${name}` 
-        });
-
-        mergeEvidenceMap(usageMap, name, ev);
-
-        const sig = detectDefaultSignals(p);
-        if (sig.hasDefault) usageMap[name].signals.hasDefault = true;
-      }
-    });
-  }
-
-  return usageMap;
-}
-
-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;
-}
-
-async function resolveEnvDeclared(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);
-    if (!fs.existsSync(abs)) continue;
-
-    const content = safeRead(abs);
-    const keys = parseDotEnvLike(content);
-    if (keys.size) {
-      for (const k of keys) declared.add(k);
-      sources.push(rel);
-    }
-  }
-
-  return { declared: Array.from(declared).sort(), sources };
-}
-
-async function buildEnvTruth(repoRoot) {
-  const usageMap = await resolveEnvUsage(repoRoot);
-  const declared = await resolveEnvDeclared(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 = { buildEnvTruth };
+// bin/runners/lib/env.js
+const fg = require("fast-glob");
+const fs = require("fs");
+const path = require("path");
+const parser = require("@babel/parser");
+const traverse = require("@babel/traverse").default;
+const t = require("@babel/types");
+const crypto = require("crypto");
+
+function sha256(text) {
+  return "sha256:" + crypto.createHash("sha256").update(text).digest("hex");
+}
+
+function parseFile(code) {
+  return parser.parse(code, { sourceType: "unambiguous", plugins: ["typescript", "jsx"] });
+}
+
+function safeRead(fileAbs) {
+  return fs.readFileSync(fileAbs, "utf8");
+}
+
+function evidenceFromLoc({ fileAbs, fileRel, loc, reason }) {
+  if (!loc) return null;
+  const lines = safeRead(fileAbs).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 mergeEvidenceMap(map, name, ev) {
+  map[name] = map[name] || { name, references: [], signals: { hasDefault: false } };
+  if (ev) map[name].references.push(ev);
+}
+
+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 };
+}
+
+async function resolveEnvUsage(repoRoot) {
+  const files = await fg(["**/*.{ts,tsx,js,jsx}"], {
+    cwd: repoRoot,
+    absolute: true,
+    ignore: ["**/node_modules/**","**/.next/**","**/dist/**","**/build/**"]
+  });
+
+  const usageMap = {};
+
+  for (const fileAbs of files) {
+    const fileRel = path.relative(repoRoot, fileAbs).replace(/\\/g, "/");
+    const code = safeRead(fileAbs);
+
+    let ast;
+    try { ast = parseFile(code); } catch { continue; }
+
+    traverse(ast, {
+      MemberExpression(p) {
+        const name = extractEnvFromMemberExpr(p.node);
+        if (!name || !isEnvName(name)) return;
+
+        const ev = evidenceFromLoc({
+          fileAbs,
+          fileRel,
+          loc: p.node.loc,
+          reason: `Env usage: ${name}` 
+        });
+
+        mergeEvidenceMap(usageMap, name, ev);
+
+        const sig = detectDefaultSignals(p);
+        if (sig.hasDefault) usageMap[name].signals.hasDefault = true;
+      }
+    });
+  }
+
+  return usageMap;
+}
+
+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;
+}
+
+async function resolveEnvDeclared(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);
+    if (!fs.existsSync(abs)) continue;
+
+    const content = safeRead(abs);
+    const keys = parseDotEnvLike(content);
+    if (keys.size) {
+      for (const k of keys) declared.add(k);
+      sources.push(rel);
+    }
+  }
+
+  return { declared: Array.from(declared).sort(), sources };
+}
+
+async function buildEnvTruth(repoRoot) {
+  const usageMap = await resolveEnvUsage(repoRoot);
+  const declared = await resolveEnvDeclared(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 = { buildEnvTruth };

package/bin/runners/lib/error-handler.js

@@ -1,12 +1,20 @@
 /**
  * Standardized error handling for CLI runners
  * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * World-Class Error Handling
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 
  * Design principles:
  * - Every error has a human-readable message
  * - Every error suggests a next step
  * - Exit codes are consistent and documented
+ * - Errors include "receipt" (file:line evidence) where possible
+ * - Debug mode shows stack traces
  */
 
+const { EXIT, getExitInfo, getHint } = require("./exit-codes");
+
 const colors = {
   reset: "\x1b[0m",
   red: "\x1b[31m",
@@ -24,16 +32,15 @@ const c = {
   dim: (text) => `\x1b[2m${text}${colors.reset}`,
 };
 
-// Standard exit codes for CI/CD integration
-// Unified with packages/cli/src/runtime/exit-codes.ts
-// IMPORTANT: These codes are part of the CLI contract - do not change without migration guide
+// Re-export EXIT for backward compatibility
+// NOTE: Prefer importing from exit-codes.js directly
 const EXIT_CODES = {
-  SUCCESS: 0,           // Scan passed, no policy violations
-  POLICY_FAIL: 1,       // Findings above threshold (policy fail) - actionable by user
-  USER_ERROR: 2,        // User error: invalid args, bad config, missing required options
-  SYSTEM_ERROR: 3,      // System error: crash, filesystem issues, unexpected exceptions
-  AUTH_FAILURE: 4,      // Auth/entitlement failure: invalid key, expired token, insufficient tier
-  NETWORK_FAILURE: 5,   // Network/backend failure: API unreachable, timeout
+  SUCCESS: EXIT.SUCCESS,
+  POLICY_FAIL: EXIT.WARNINGS,       // Findings above threshold (policy fail)
+  USER_ERROR: EXIT.USER_ERROR,      // User error: invalid args, bad config
+  SYSTEM_ERROR: EXIT.INTERNAL_ERROR, // System error: crash, unexpected exceptions
+  AUTH_FAILURE: EXIT.AUTH_REQUIRED,  // Auth/entitlement failure
+  NETWORK_FAILURE: EXIT.NETWORK_ERROR, // Network/backend failure
 };
 
 // Error-specific guidance