burnwatch 0.13.1 → 0.14.0

package/dist/hooks/on-file-change.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/hooks/on-file-change.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 
 // src/core/config.ts
 import * as fs from "fs";
@@ -198,6 +198,37 @@ function readLatestSnapshot(projectRoot) {
 }
 
 // src/cost-impact.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import * as url2 from "url";
+var __dirname2 = path5.dirname(url2.fileURLToPath(import.meta.url));
+var manifestCache = null;
+function loadBillingManifests() {
+  if (manifestCache) return manifestCache;
+  manifestCache = /* @__PURE__ */ new Map();
+  const candidates = [
+    path5.resolve(__dirname2, "../billing"),
+    // from src/ during dev
+    path5.resolve(__dirname2, "../../billing")
+    // from dist/
+  ];
+  for (const dir of candidates) {
+    if (!fs5.existsSync(dir)) continue;
+    const files = fs5.readdirSync(dir).filter((f) => f.endsWith(".json") && f !== "billing.schema.json");
+    for (const file of files) {
+      try {
+        const raw = fs5.readFileSync(path5.join(dir, file), "utf-8");
+        const manifest = JSON.parse(raw);
+        if (manifest.serviceId) {
+          manifestCache.set(manifest.serviceId, manifest);
+        }
+      } catch {
+      }
+    }
+    break;
+  }
+  return manifestCache;
+}
 var SERVICE_CALL_PATTERNS = {
   anthropic: [
     /\.messages\.create\s*\(/g,
@@ -243,11 +274,6 @@ var SERVICE_CALL_PATTERNS = {
     /resend\.emails\.send\s*\(/g,
     /\.emails\.send\s*\(/g
   ],
-  stripe: [
-    /stripe\.charges\.create\s*\(/g,
-    /stripe\.paymentIntents\.create\s*\(/g,
-    /stripe\.checkout\.sessions\.create\s*\(/g
-  ],
   supabase: [
     /supabase\.from\s*\(/g,
     /\.rpc\s*\(/g,
@@ -261,11 +287,6 @@ var SERVICE_CALL_PATTERNS = {
     /posthog\.capture\s*\(/g,
     /\.capture\s*\(/g
   ],
-  aws: [
-    /\.send\s*\(new\s+\w+Command/g,
-    /s3Client\.send\s*\(/g,
-    /lambdaClient\.send\s*\(/g
-  ],
   firebase: [
     /firestore\.\w+\(\s*["']/g,
     /\.collection\s*\(/g,
@@ -295,40 +316,134 @@ var SERVICE_CALL_PATTERNS = {
   replicate: [
     /replicate\.run\s*\(/g,
     /replicate\.predictions\.create\s*\(/g
+  ],
+  vercel: [
+    /\.functions\./g,
+    /edge\s+function/gi
   ]
 };
+function extractNumericContext(content) {
+  const ctx = /* @__PURE__ */ new Map();
+  const assignRegex = /(?:const|let|var)\s+(\w+)\s*=\s*(\d+)\s*[;,\n]/g;
+  let m;
+  while ((m = assignRegex.exec(content)) !== null) {
+    ctx.set(m[1], parseInt(m[2], 10));
+  }
+  const arrayCtorRegex = /(?:const|let|var)\s+(\w+)\s*=\s*(?:new\s+)?Array\s*\(\s*(\d+)\s*\)/g;
+  while ((m = arrayCtorRegex.exec(content)) !== null) {
+    ctx.set(m[1], parseInt(m[2], 10));
+  }
+  const arrayLitRegex = /(?:const|let|var)\s+(\w+)\s*=\s*\[([^\]]*)\]/g;
+  while ((m = arrayLitRegex.exec(content)) !== null) {
+    const elements = m[2].split(",").filter((e) => e.trim().length > 0);
+    if (elements.length > 1) {
+      ctx.set(m[1], elements.length);
+    }
+  }
+  return ctx;
+}
+function resolveLoopBound(varName, content, ctx) {
+  const num = parseInt(varName, 10);
+  if (!isNaN(num) && num > 0) return num;
+  if (ctx.has(varName)) return ctx.get(varName);
+  const lengthMatch = varName.match(/^(\w+)\.length$/);
+  if (lengthMatch && ctx.has(lengthMatch[1])) {
+    return ctx.get(lengthMatch[1]);
+  }
+  return null;
+}
+function resolveIterableSize(content, ctx) {
+  const forOfMatch = content.match(/for\s*\(\s*(?:const|let|var)\s+\w+\s+of\s+(\w+)/);
+  if (forOfMatch) {
+    const resolved = ctx.get(forOfMatch[1]);
+    if (resolved) return resolved;
+  }
+  const iterMatch = content.match(/(\w+)\s*\.\s*(?:map|forEach)\s*\(/);
+  if (iterMatch) {
+    const resolved = ctx.get(iterMatch[1]);
+    if (resolved) return resolved;
+  }
+  return null;
+}
 function detectMultipliers(content) {
   const multipliers = [];
-  if (/for\s*\(.*;\s*\w+\s*<\s*(\w+)/g.test(content)) {
-    const loopMatch = content.match(/for\s*\(.*;\s*\w+\s*<\s*(\d+)/);
-    if (loopMatch) {
-      const bound = parseInt(loopMatch[1]);
-      if (bound > 1) {
-        multipliers.push({ label: `for loop (${bound} iterations)`, factor: bound });
-      }
+  const ctx = extractNumericContext(content);
+  const forLoopRegex = /for\s*\(.*;\s*\w+\s*(?:<|<=)\s*([\w.]+)/g;
+  const forLoopMatch = forLoopRegex.exec(content);
+  if (forLoopMatch) {
+    const boundExpr = forLoopMatch[1];
+    const resolved = resolveLoopBound(boundExpr, content, ctx);
+    if (resolved && resolved > 1) {
+      multipliers.push({ label: `for loop (${resolved} iterations)`, factor: resolved });
     } else {
-      multipliers.push({ label: "for loop (variable bound)", factor: 10 });
+      const hintMatch = content.match(new RegExp(`(?:const|let|var)\\s+${boundExpr}\\s*=\\s*(\\w+)\\.length`));
+      if (hintMatch) {
+        const arrayName = hintMatch[1];
+        const arraySize = ctx.get(arrayName);
+        if (arraySize && arraySize > 1) {
+          multipliers.push({ label: `for loop (${arraySize} iterations via ${arrayName}.length)`, factor: arraySize });
+        } else {
+          multipliers.push({ label: `for loop (${arrayName}.length \u2014 variable bound)`, factor: 10 });
+        }
+      } else {
+        multipliers.push({ label: "for loop (variable bound)", factor: 10 });
+      }
     }
   }
   if (/\.\s*map\s*\(\s*(async\s*)?\(/g.test(content)) {
-    multipliers.push({ label: ".map() iteration", factor: 10 });
-  }
-  if (/\.\s*forEach\s*\(\s*(async\s*)?\(/g.test(content)) {
-    multipliers.push({ label: ".forEach() iteration", factor: 10 });
+    const size = resolveIterableSize(content, ctx);
+    if (size && size > 1) {
+      multipliers.push({ label: `.map() over ${size} items`, factor: size });
+    } else {
+      multipliers.push({ label: ".map() iteration", factor: 10 });
+    }
+  } else if (/\.\s*forEach\s*\(\s*(async\s*)?\(/g.test(content)) {
+    const size = resolveIterableSize(content, ctx);
+    if (size && size > 1) {
+      multipliers.push({ label: `.forEach() over ${size} items`, factor: size });
+    } else {
+      multipliers.push({ label: ".forEach() iteration", factor: 10 });
+    }
   }
   if (/for\s*\(\s*(const|let|var)\s+\w+\s+(of|in)\s+/g.test(content)) {
-    multipliers.push({ label: "for...of/in loop", factor: 10 });
+    const size = resolveIterableSize(content, ctx);
+    if (size && size > 1) {
+      multipliers.push({ label: `for...of over ${size} items`, factor: size });
+    } else {
+      multipliers.push({ label: "for...of/in loop", factor: 10 });
+    }
   }
   if (/Promise\.all\s*\(/g.test(content)) {
-    multipliers.push({ label: "Promise.all (parallel batch)", factor: 10 });
+    const hasMap = multipliers.some((m) => m.label.includes(".map()"));
+    if (!hasMap) {
+      multipliers.push({ label: "Promise.all (parallel batch)", factor: 10 });
+    }
   }
-  if (/cron|schedule|interval|setInterval|every\s+\d+\s*(min|hour|day|sec)/gi.test(content)) {
+  if (/cron|schedule|interval|setInterval|every\s+(?:\d+|other)\s*(min|hour|day|sec|week)/gi.test(content)) {
     if (/every\s+5\s*min/gi.test(content) || /\*\/5\s+\*\s+\*/g.test(content)) {
       multipliers.push({ label: "cron: every 5 minutes", factor: 8640 });
+    } else if (/every\s+15\s*min/gi.test(content) || /\*\/15\s+\*\s+\*/g.test(content)) {
+      multipliers.push({ label: "cron: every 15 minutes", factor: 2880 });
+    } else if (/every\s+30\s*min/gi.test(content) || /\*\/30\s+\*\s+\*/g.test(content)) {
+      multipliers.push({ label: "cron: every 30 minutes", factor: 1440 });
     } else if (/every\s+1?\s*hour/gi.test(content) || /0\s+\*\s+\*\s+\*/g.test(content)) {
       multipliers.push({ label: "cron: hourly", factor: 720 });
+    } else if (/every\s+(\d+)\s*hours?/gi.test(content)) {
+      const hoursMatch = content.match(/every\s+(\d+)\s*hours?/i);
+      const hours = parseInt(hoursMatch[1], 10);
+      const factor = Math.round(720 / hours);
+      multipliers.push({ label: `cron: every ${hours} hours`, factor });
+    } else if (/every\s+other\s+day|every\s+2\s*days?/gi.test(content) || /\*\/2\s+/g.test(content)) {
+      multipliers.push({ label: "cron: every other day", factor: 15 });
+    } else if (/every\s+(\d+)\s*days?/gi.test(content)) {
+      const daysMatch = content.match(/every\s+(\d+)\s*days?/i);
+      const days = parseInt(daysMatch[1], 10);
+      const factor = Math.round(30 / days);
+      multipliers.push({ label: `cron: every ${days} days`, factor });
     } else if (/every\s+1?\s*day/gi.test(content) || /0\s+0\s+\*\s+\*/g.test(content)) {
       multipliers.push({ label: "cron: daily", factor: 30 });
+    } else if (/every\s+1?\s*week/gi.test(content) || /0\s+0\s+\*\s+\*\s+0/g.test(content)) {
+      multipliers.push({ label: "cron: weekly", factor: 4 });
     } else {
       multipliers.push({ label: "scheduled execution", factor: 30 });
     }
@@ -340,40 +455,92 @@ function detectMultipliers(content) {
       multipliers.push({ label: `batch size: ${batchSize}`, factor: batchSize });
     }
   }
+  for (const [name, value] of ctx) {
+    if (value >= 100 && /^(total|count|num|max|limit|size|pages|items|urls|batch)/i.test(name)) {
+      const alreadyCovered = multipliers.some((m) => m.factor === value);
+      if (!alreadyCovered) {
+        multipliers.push({ label: `${name} = ${value}`, factor: value });
+      }
+    }
+  }
   return multipliers;
 }
-var GOTCHA_MULTIPLIERS = {
-  scrapfly: {
-    low: 1,
-    high: 25,
-    explanation: "anti-bot bypass consumes 5-25x base credits"
-  },
-  browserbase: {
-    low: 1,
-    high: 5,
-    explanation: "session duration affects cost \u2014 long sessions burn more"
-  },
-  anthropic: {
-    low: 1,
-    high: 60,
-    explanation: "Haiku ~$0.25/MTok vs Opus ~$15/MTok (60x range)"
-  },
-  openai: {
-    low: 1,
-    high: 30,
-    explanation: "GPT-4 mini vs GPT-5 (30x cost range)"
-  },
-  stripe: {
+function detectVariant(dimension, content) {
+  if (!dimension.variants || dimension.variants.length === 0) return void 0;
+  for (const variant of dimension.variants) {
+    if (!variant.codePatterns) continue;
+    for (const pattern of variant.codePatterns) {
+      try {
+        if (new RegExp(pattern, "i").test(content)) {
+          return variant;
+        }
+      } catch {
+      }
+    }
+  }
+  return dimension.variants.find((v) => v.isDefault);
+}
+function detectManifestMultipliers(manifest, content) {
+  if (!manifest.costMultipliers || manifest.costMultipliers.length === 0) {
+    return void 0;
+  }
+  let maxFactor = 1;
+  const activeNames = [];
+  for (const cm of manifest.costMultipliers) {
+    if (!cm.codePatterns) continue;
+    for (const pattern of cm.codePatterns) {
+      try {
+        if (new RegExp(pattern, "i").test(content)) {
+          maxFactor = Math.max(maxFactor, cm.factor);
+          activeNames.push(cm.name);
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  if (activeNames.length === 0) return void 0;
+  return {
     low: 1,
-    high: 1.5,
-    explanation: "international cards add 1-1.5% extra"
+    high: maxFactor,
+    explanation: activeNames.join(", ")
+  };
+}
+function computeManifestPerCallCost(manifest, content) {
+  let totalPerCall = 0;
+  const parts = [];
+  const unitsPerCall = manifest.typicalDevUsage?.unitsPerCall ?? 1;
+  for (const dim of manifest.billingDimensions) {
+    const variant = detectVariant(dim, content);
+    const ratePerUnit = variant?.ratePerUnit ?? dim.ratePerUnit;
+    const ratePer = variant?.ratePer ?? dim.ratePer ?? 1;
+    const dimCostPerCall = unitsPerCall / ratePer * ratePerUnit;
+    if (dimCostPerCall > 0) {
+      totalPerCall += dimCostPerCall;
+      const variantLabel = variant?.name ?? dim.name;
+      parts.push(variantLabel);
+    }
   }
+  return {
+    perCall: totalPerCall,
+    explanation: parts.length > 0 ? parts.join(" + ") : manifest.name
+  };
+}
+var LEGACY_GOTCHA_MULTIPLIERS = {};
+var LEGACY_CALL_COSTS = {
+  firebase: 1e-4,
+  twilio: 0.01,
+  sendgrid: 1e-3,
+  "mongodb-atlas": 1e-4,
+  clerk: 0,
+  replicate: 0.01
 };
 function analyzeCostImpact(filePath, content, projectRoot) {
-  if (!/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(filePath)) {
+  if (!/\.(ts|tsx|js|jsx|mjs|cjs|py)$/.test(filePath)) {
     return [];
   }
   const registry = loadRegistry(projectRoot);
+  const manifests = loadBillingManifests();
   const impacts = [];
   const multipliers = detectMultipliers(content);
   for (const [serviceId, patterns] of Object.entries(SERVICE_CALL_PATTERNS)) {
@@ -389,32 +556,48 @@ function analyzeCostImpact(filePath, content, projectRoot) {
     const service = registry.get(serviceId);
     if (!service) continue;
     const multiplierFactor = multipliers.length > 0 ? multipliers.reduce((max, m) => Math.max(max, m.factor), 1) : 1;
-    const baseMonthlyRuns = multipliers.some((m) => m.label.startsWith("cron")) ? 1 : 50;
+    const manifest = manifests.get(serviceId);
+    let baseMonthlyRuns;
+    const isCron = multipliers.some((m) => m.label.startsWith("cron"));
+    if (isCron) {
+      baseMonthlyRuns = 1;
+    } else if (manifest?.typicalDevUsage?.callsPerDevHour && manifest.typicalDevUsage.callsPerDevHour > 0) {
+      baseMonthlyRuns = 132;
+    } else {
+      baseMonthlyRuns = 50;
+    }
     const monthlyInvocations = totalCalls * multiplierFactor * baseMonthlyRuns;
-    const gotcha = GOTCHA_MULTIPLIERS[serviceId];
-    const unitRate = service.pricing?.unitRate ?? 0;
     let costLow;
     let costHigh;
-    if (unitRate > 0) {
-      costLow = monthlyInvocations * unitRate * (gotcha?.low ?? 1);
-      costHigh = monthlyInvocations * unitRate * (gotcha?.high ?? 1);
-    } else if (service.pricing?.monthlyBase !== void 0) {
-      costLow = 0;
-      costHigh = 0;
-    } else {
-      const typicalCallCosts = {
-        anthropic: 3e-3,
-        // ~$3/MTok * ~1K tokens average
-        openai: 2e-3,
-        "google-gemini": 1e-3,
-        scrapfly: 15e-5,
-        browserbase: 0.01,
-        resend: 1e-3,
-        stripe: 0.3
-      };
-      const perCall = typicalCallCosts[serviceId] ?? 1e-3;
+    let rangeExplanation;
+    if (manifest) {
+      const { perCall } = computeManifestPerCallCost(manifest, content);
+      const gotcha = detectManifestMultipliers(manifest, content);
       costLow = monthlyInvocations * perCall * (gotcha?.low ?? 1);
       costHigh = monthlyInvocations * perCall * (gotcha?.high ?? 1);
+      rangeExplanation = gotcha?.explanation;
+      if (!gotcha && manifest.costMultipliers && manifest.costMultipliers.length > 0) {
+        const maxFactor = Math.max(...manifest.costMultipliers.map((m) => m.factor));
+        if (maxFactor > 1) {
+          costHigh = monthlyInvocations * perCall * maxFactor;
+          rangeExplanation = manifest.costMultipliers.map((m) => m.description).join("; ");
+        }
+      }
+    } else {
+      const gotcha = LEGACY_GOTCHA_MULTIPLIERS[serviceId];
+      const unitRate = service.pricing?.unitRate ?? 0;
+      if (unitRate > 0) {
+        costLow = monthlyInvocations * unitRate * (gotcha?.low ?? 1);
+        costHigh = monthlyInvocations * unitRate * (gotcha?.high ?? 1);
+      } else if (service.pricing?.monthlyBase !== void 0 && service.pricing.monthlyBase > 0) {
+        costLow = 0;
+        costHigh = 0;
+      } else {
+        const perCall = LEGACY_CALL_COSTS[serviceId] ?? 1e-3;
+        costLow = monthlyInvocations * perCall * (gotcha?.low ?? 1);
+        costHigh = monthlyInvocations * perCall * (gotcha?.high ?? 1);
+      }
+      rangeExplanation = gotcha?.explanation;
     }
     if (costLow === 0 && costHigh === 0) continue;
     impacts.push({
@@ -427,7 +610,7 @@ function analyzeCostImpact(filePath, content, projectRoot) {
       monthlyInvocations,
       costLow,
       costHigh,
-      rangeExplanation: gotcha?.explanation
+      rangeExplanation
     });
   }
   return impacts;
@@ -464,14 +647,14 @@ function formatCostImpactCard(impacts, currentBudgets) {
 }
 
 // src/utilization.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 function utilizationModelPath(projectRoot) {
-  return path5.join(projectDataDir(projectRoot), "utilization.json");
+  return path6.join(projectDataDir(projectRoot), "utilization.json");
 }
 function readUtilizationModel(projectRoot) {
   try {
-    const raw = fs5.readFileSync(utilizationModelPath(projectRoot), "utf-8");
+    const raw = fs6.readFileSync(utilizationModelPath(projectRoot), "utf-8");
     return JSON.parse(raw);
   } catch {
     return {
@@ -484,9 +667,9 @@ function readUtilizationModel(projectRoot) {
 }
 function writeUtilizationModel(model, projectRoot) {
   const dir = projectDataDir(projectRoot);
-  fs5.mkdirSync(dir, { recursive: true });
+  fs6.mkdirSync(dir, { recursive: true });
   model.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  fs5.writeFileSync(
+  fs6.writeFileSync(
     utilizationModelPath(projectRoot),
     JSON.stringify(model, null, 2) + "\n",
     "utf-8"
@@ -559,20 +742,20 @@ function recalculateServiceTotals(model, serviceId) {
 
 // src/hooks/on-file-change.ts
 function sessionImpactPath(projectRoot, sessionId) {
-  return path6.join(projectDataDir(projectRoot), "cache", `session-impact-${sessionId}.json`);
+  return path7.join(projectDataDir(projectRoot), "cache", `session-impact-${sessionId}.json`);
 }
 function readSessionImpacts(projectRoot, sessionId) {
   try {
-    const raw = fs6.readFileSync(sessionImpactPath(projectRoot, sessionId), "utf-8");
+    const raw = fs7.readFileSync(sessionImpactPath(projectRoot, sessionId), "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
   }
 }
 function writeSessionImpacts(projectRoot, sessionId, impacts) {
-  const dir = path6.join(projectDataDir(projectRoot), "cache");
-  fs6.mkdirSync(dir, { recursive: true });
-  fs6.writeFileSync(
+  const dir = path7.join(projectDataDir(projectRoot), "cache");
+  fs7.mkdirSync(dir, { recursive: true });
+  fs7.writeFileSync(
     sessionImpactPath(projectRoot, sessionId),
     JSON.stringify(impacts, null, 2) + "\n",
     "utf-8"
@@ -581,7 +764,7 @@ function writeSessionImpacts(projectRoot, sessionId, impacts) {
 function main() {
   let input;
   try {
-    const stdin = fs6.readFileSync(0, "utf-8");
+    const stdin = fs7.readFileSync(0, "utf-8");
     input = JSON.parse(stdin);
   } catch {
     process.exit(0);
@@ -599,7 +782,7 @@ function main() {
   }
   let content;
   try {
-    content = fs6.readFileSync(filePath, "utf-8");
+    content = fs7.readFileSync(filePath, "utf-8");
   } catch {
     process.exit(0);
     return;
@@ -692,7 +875,7 @@ function main() {
     );
   }
   try {
-    const relPath = path6.relative(projectRoot, filePath);
+    const relPath = path7.relative(projectRoot, filePath);
     const callSites = analyzeFileUtilization(filePath, content, projectRoot).map(
       (cs) => ({ ...cs, filePath: relPath })
     );