burnwatch 0.1.0

package/dist/cli.js

@@ -0,0 +1,1151 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+
+// src/core/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+function globalConfigDir() {
+  const xdgConfig = process.env["XDG_CONFIG_HOME"];
+  if (xdgConfig) return path.join(xdgConfig, "burnwatch");
+  return path.join(os.homedir(), ".config", "burnwatch");
+}
+function projectConfigDir(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  return path.join(root, ".burnwatch");
+}
+function projectDataDir(projectRoot) {
+  return path.join(projectConfigDir(projectRoot), "data");
+}
+function readGlobalConfig() {
+  const configPath = path.join(globalConfigDir(), "config.json");
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { services: {} };
+  }
+}
+function writeGlobalConfig(config) {
+  const dir = globalConfigDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const configPath = path.join(dir, "config.json");
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs.chmodSync(configPath, 384);
+}
+function readProjectConfig(projectRoot) {
+  const configPath = path.join(projectConfigDir(projectRoot), "config.json");
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeProjectConfig(config, projectRoot) {
+  const dir = projectConfigDir(projectRoot);
+  fs.mkdirSync(dir, { recursive: true });
+  config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const configPath = path.join(dir, "config.json");
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function ensureProjectDirs(projectRoot) {
+  const dirs = [
+    projectConfigDir(projectRoot),
+    projectDataDir(projectRoot),
+    path.join(projectDataDir(projectRoot), "cache"),
+    path.join(projectDataDir(projectRoot), "snapshots")
+  ];
+  for (const dir of dirs) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function isInitialized(projectRoot) {
+  return readProjectConfig(projectRoot) !== null;
+}
+
+// src/detection/detector.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// src/core/registry.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as url from "url";
+var __dirname = path2.dirname(url.fileURLToPath(import.meta.url));
+var cachedRegistry = null;
+function loadRegistry(projectRoot) {
+  if (cachedRegistry) return cachedRegistry;
+  const registry = /* @__PURE__ */ new Map();
+  const candidates = [
+    path2.resolve(__dirname, "../../registry.json"),
+    // from src/core/
+    path2.resolve(__dirname, "../registry.json")
+    // from dist/
+  ];
+  for (const candidate of candidates) {
+    if (fs2.existsSync(candidate)) {
+      loadRegistryFile(candidate, registry);
+      break;
+    }
+  }
+  if (projectRoot) {
+    const localPath = path2.join(projectRoot, ".burnwatch", "registry.json");
+    if (fs2.existsSync(localPath)) {
+      loadRegistryFile(localPath, registry);
+    }
+  }
+  cachedRegistry = registry;
+  return registry;
+}
+function loadRegistryFile(filePath, registry) {
+  try {
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    for (const [id, service] of Object.entries(data.services)) {
+      registry.set(id, { ...service, id });
+    }
+  } catch {
+  }
+}
+function getService(id, projectRoot) {
+  return loadRegistry(projectRoot).get(id);
+}
+function getAllServices(projectRoot) {
+  return Array.from(loadRegistry(projectRoot).values());
+}
+
+// src/detection/detector.ts
+function detectServices(projectRoot) {
+  const registry = loadRegistry(projectRoot);
+  const results = /* @__PURE__ */ new Map();
+  const pkgDeps = scanPackageJson(projectRoot);
+  for (const [serviceId, service] of registry) {
+    const matchedPkgs = service.packageNames.filter(
+      (pkg) => pkgDeps.has(pkg)
+    );
+    if (matchedPkgs.length > 0) {
+      getOrCreate(results, serviceId, service).sources.push("package_json");
+      getOrCreate(results, serviceId, service).details.push(
+        `package.json: ${matchedPkgs.join(", ")}`
+      );
+    }
+  }
+  const envVars = new Set(Object.keys(process.env));
+  for (const [serviceId, service] of registry) {
+    const matchedEnvs = service.envPatterns.filter(
+      (pattern) => envVars.has(pattern)
+    );
+    if (matchedEnvs.length > 0) {
+      getOrCreate(results, serviceId, service).sources.push("env_var");
+      getOrCreate(results, serviceId, service).details.push(
+        `env vars: ${matchedEnvs.join(", ")}`
+      );
+    }
+  }
+  const importHits = scanImports(projectRoot);
+  for (const [serviceId, service] of registry) {
+    const matchedImports = service.importPatterns.filter(
+      (pattern) => importHits.has(pattern)
+    );
+    if (matchedImports.length > 0) {
+      if (!getOrCreate(results, serviceId, service).sources.includes(
+        "import_scan"
+      )) {
+        getOrCreate(results, serviceId, service).sources.push("import_scan");
+        getOrCreate(results, serviceId, service).details.push(
+          `imports: ${matchedImports.join(", ")}`
+        );
+      }
+    }
+  }
+  return Array.from(results.values());
+}
+function getOrCreate(map, serviceId, service) {
+  let result = map.get(serviceId);
+  if (!result) {
+    result = { service, sources: [], details: [] };
+    map.set(serviceId, result);
+  }
+  return result;
+}
+function scanPackageJson(projectRoot) {
+  const deps = /* @__PURE__ */ new Set();
+  const pkgPath = path3.join(projectRoot, "package.json");
+  try {
+    const raw = fs3.readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    for (const name of Object.keys(pkg.dependencies ?? {})) deps.add(name);
+    for (const name of Object.keys(pkg.devDependencies ?? {})) deps.add(name);
+  } catch {
+  }
+  return deps;
+}
+function scanImports(projectRoot) {
+  const imports = /* @__PURE__ */ new Set();
+  const srcDir = path3.join(projectRoot, "src");
+  if (!fs3.existsSync(srcDir)) return imports;
+  const files = walkDir(srcDir, /\.(ts|tsx|js|jsx|mjs|cjs)$/);
+  for (const file of files) {
+    try {
+      const content = fs3.readFileSync(file, "utf-8");
+      const importRegex = /(?:from\s+["']|require\s*\(\s*["'])([^./][^"']*?)(?:["'])/g;
+      let match;
+      while ((match = importRegex.exec(content)) !== null) {
+        const pkg = match[1];
+        if (pkg) {
+          const parts = pkg.split("/");
+          if (parts[0]?.startsWith("@") && parts.length >= 2) {
+            imports.add(`${parts[0]}/${parts[1]}`);
+          } else if (parts[0]) {
+            imports.add(parts[0]);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return imports;
+}
+function walkDir(dir, pattern, maxDepth = 5) {
+  const results = [];
+  if (maxDepth <= 0) return results;
+  try {
+    const entries = fs3.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const fullPath = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...walkDir(fullPath, pattern, maxDepth - 1));
+      } else if (pattern.test(entry.name)) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+
+// src/services/base.ts
+async function fetchJson(url2, options = {}) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      options.timeout ?? 1e4
+    );
+    const response = await fetch(url2, {
+      method: options.method ?? "GET",
+      headers: options.headers,
+      body: options.body,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return {
+        ok: false,
+        status: response.status,
+        error: `HTTP ${response.status}: ${response.statusText}`
+      };
+    }
+    const data = await response.json();
+    return { ok: true, status: response.status, data };
+  } catch (err) {
+    return {
+      ok: false,
+      status: 0,
+      error: err instanceof Error ? err.message : "Unknown error"
+    };
+  }
+}
+
+// src/services/anthropic.ts
+var anthropicConnector = {
+  serviceId: "anthropic",
+  async fetchSpend(apiKey) {
+    const now = /* @__PURE__ */ new Date();
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+    const startDate = startOfMonth.toISOString().split("T")[0];
+    const endDate = now.toISOString().split("T")[0];
+    const url2 = `https://api.anthropic.com/v1/organizations/usage?start_date=${startDate}&end_date=${endDate}`;
+    const result = await fetchJson(url2, {
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      }
+    });
+    if (!result.ok || !result.data) {
+      return {
+        serviceId: "anthropic",
+        spend: 0,
+        isEstimate: true,
+        tier: "est",
+        error: result.error ?? "Failed to fetch Anthropic usage"
+      };
+    }
+    let totalSpend = 0;
+    if (result.data.total_cost_usd !== void 0) {
+      totalSpend = result.data.total_cost_usd;
+    } else if (result.data.data) {
+      totalSpend = result.data.data.reduce(
+        (sum, entry) => sum + (entry.total_cost_usd ?? entry.spend ?? 0),
+        0
+      );
+    }
+    return {
+      serviceId: "anthropic",
+      spend: totalSpend,
+      isEstimate: false,
+      tier: "live",
+      raw: result.data
+    };
+  }
+};
+
+// src/services/openai.ts
+var openaiConnector = {
+  serviceId: "openai",
+  async fetchSpend(apiKey) {
+    const now = /* @__PURE__ */ new Date();
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+    const startTime = Math.floor(startOfMonth.getTime() / 1e3);
+    const url2 = `https://api.openai.com/v1/organization/costs?start_time=${startTime}`;
+    const result = await fetchJson(url2, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!result.ok || !result.data) {
+      return {
+        serviceId: "openai",
+        spend: 0,
+        isEstimate: true,
+        tier: "est",
+        error: result.error ?? "Failed to fetch OpenAI usage"
+      };
+    }
+    let totalSpend = 0;
+    if (result.data.data) {
+      for (const bucket of result.data.data) {
+        if (bucket.results) {
+          for (const r of bucket.results) {
+            totalSpend += r.amount?.value ?? 0;
+          }
+        }
+      }
+    }
+    totalSpend = totalSpend / 100;
+    return {
+      serviceId: "openai",
+      spend: totalSpend,
+      isEstimate: false,
+      tier: "live",
+      raw: result.data
+    };
+  }
+};
+
+// src/services/vercel.ts
+var vercelConnector = {
+  serviceId: "vercel",
+  async fetchSpend(token, options) {
+    const teamId = options?.["teamId"] ?? "";
+    const teamParam = teamId ? `?teamId=${teamId}` : "";
+    const url2 = `https://api.vercel.com/v2/usage${teamParam}`;
+    const result = await fetchJson(url2, {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (!result.ok || !result.data) {
+      return {
+        serviceId: "vercel",
+        spend: 0,
+        isEstimate: true,
+        tier: "est",
+        error: result.error ?? "Failed to fetch Vercel usage"
+      };
+    }
+    let totalSpend = 0;
+    if (result.data.usage?.total !== void 0) {
+      totalSpend = result.data.usage.total;
+    } else if (result.data.billing?.invoiceItems) {
+      totalSpend = result.data.billing.invoiceItems.reduce(
+        (sum, item) => sum + (item.amount ?? 0),
+        0
+      );
+    }
+    return {
+      serviceId: "vercel",
+      spend: totalSpend,
+      isEstimate: false,
+      tier: "live",
+      raw: result.data
+    };
+  }
+};
+
+// src/services/scrapfly.ts
+var scrapflyConnector = {
+  serviceId: "scrapfly",
+  async fetchSpend(apiKey) {
+    const url2 = `https://api.scrapfly.io/account?key=${apiKey}`;
+    const result = await fetchJson(url2);
+    if (!result.ok || !result.data) {
+      return {
+        serviceId: "scrapfly",
+        spend: 0,
+        isEstimate: true,
+        tier: "est",
+        error: result.error ?? "Failed to fetch Scrapfly account"
+      };
+    }
+    let creditsUsed = 0;
+    let creditsTotal = 0;
+    if (result.data.subscription?.usage?.scrape) {
+      creditsUsed = result.data.subscription.usage.scrape.used ?? 0;
+      creditsTotal = result.data.subscription.usage.scrape.allowed ?? 0;
+    } else if (result.data.account) {
+      creditsUsed = result.data.account.credits_used ?? 0;
+      creditsTotal = result.data.account.credits_total ?? 0;
+    }
+    const creditRate = 15e-5;
+    const spend = creditsUsed * creditRate;
+    return {
+      serviceId: "scrapfly",
+      spend,
+      isEstimate: false,
+      tier: "live",
+      raw: {
+        credits_used: creditsUsed,
+        credits_total: creditsTotal,
+        credit_rate: creditRate,
+        ...result.data
+      }
+    };
+  }
+};
+
+// src/services/index.ts
+var connectors = /* @__PURE__ */ new Map([
+  ["anthropic", anthropicConnector],
+  ["openai", openaiConnector],
+  ["vercel", vercelConnector],
+  ["scrapfly", scrapflyConnector]
+]);
+async function pollService(tracked) {
+  const globalConfig = readGlobalConfig();
+  const serviceConfig = globalConfig.services[tracked.serviceId];
+  const connector = connectors.get(tracked.serviceId);
+  const definition = getService(tracked.serviceId);
+  if (connector && serviceConfig?.apiKey) {
+    try {
+      const result = await connector.fetchSpend(
+        serviceConfig.apiKey,
+        serviceConfig
+      );
+      if (!result.error) return result;
+    } catch {
+    }
+  }
+  if (tracked.planCost !== void 0) {
+    const now = /* @__PURE__ */ new Date();
+    const daysInMonth = new Date(
+      now.getFullYear(),
+      now.getMonth() + 1,
+      0
+    ).getDate();
+    const dayOfMonth = now.getDate();
+    const projectedSpend = tracked.planCost / daysInMonth * dayOfMonth;
+    return {
+      serviceId: tracked.serviceId,
+      spend: projectedSpend,
+      isEstimate: true,
+      tier: "calc"
+    };
+  }
+  if (definition) {
+    let tier;
+    if (tracked.tierOverride) {
+      tier = tracked.tierOverride;
+    } else if (definition.apiTier === "live") {
+      tier = "blind";
+    } else {
+      tier = definition.apiTier;
+    }
+    return {
+      serviceId: tracked.serviceId,
+      spend: 0,
+      isEstimate: tier !== "live",
+      tier,
+      error: tier === "blind" ? "No API key configured" : void 0
+    };
+  }
+  return {
+    serviceId: tracked.serviceId,
+    spend: 0,
+    isEstimate: true,
+    tier: "blind",
+    error: "Unknown service \u2014 not in registry"
+  };
+}
+async function pollAllServices(services) {
+  return Promise.all(services.map(pollService));
+}
+
+// src/core/types.ts
+var CONFIDENCE_BADGES = {
+  live: "\u2705 LIVE",
+  calc: "\u{1F7E1} CALC",
+  est: "\u{1F7E0} EST",
+  blind: "\u{1F534} BLIND"
+};
+
+// src/core/brief.ts
+function formatBrief(brief) {
+  const lines = [];
+  const width = 62;
+  const hrDouble = "\u2550".repeat(width);
+  const hrSingle = "\u2500".repeat(width - 4);
+  lines.push(`\u2554${hrDouble}\u2557`);
+  lines.push(
+    `\u2551  BURNWATCH \u2014 ${brief.projectName} \u2014 ${brief.period}`.padEnd(
+      width + 1
+    ) + "\u2551"
+  );
+  lines.push(`\u2560${hrDouble}\u2563`);
+  lines.push(
+    formatRow("Service", "Spend", "Conf", "Budget", "Left", width)
+  );
+  lines.push(`\u2551  ${hrSingle}  \u2551`);
+  for (const svc of brief.services) {
+    const spendStr = svc.isEstimate ? `~$${svc.spend.toFixed(2)}` : `$${svc.spend.toFixed(2)}`;
+    const badge = CONFIDENCE_BADGES[svc.tier];
+    const budgetStr = svc.budget ? `$${svc.budget}` : "\u2014";
+    const leftStr = formatLeft(svc);
+    lines.push(formatRow(svc.serviceId, spendStr, badge, budgetStr, leftStr, width));
+  }
+  lines.push(`\u2560${hrDouble}\u2563`);
+  const totalStr = brief.totalIsEstimate ? `~$${brief.totalSpend.toFixed(2)}` : `$${brief.totalSpend.toFixed(2)}`;
+  const marginStr = brief.estimateMargin > 0 ? `  Est margin: \xB1$${brief.estimateMargin.toFixed(0)}` : "";
+  const untrackedStr = brief.untrackedCount > 0 ? `Untracked: ${brief.untrackedCount} \u26A0\uFE0F` : `Untracked: 0 \u2705`;
+  lines.push(
+    `\u2551  TOTAL: ${totalStr}   ${untrackedStr}${marginStr}`.padEnd(
+      width + 1
+    ) + "\u2551"
+  );
+  for (const alert of brief.alerts) {
+    const icon = alert.severity === "critical" ? "\u{1F6A8}" : "\u26A0\uFE0F";
+    lines.push(
+      `\u2551  ${icon}  ${alert.message}`.padEnd(width + 1) + "\u2551"
+    );
+  }
+  lines.push(`\u255A${hrDouble}\u255D`);
+  return lines.join("\n");
+}
+function buildBrief(projectName, snapshots, blindCount) {
+  const now = /* @__PURE__ */ new Date();
+  const period = now.toLocaleDateString("en-US", {
+    month: "long",
+    year: "numeric"
+  });
+  let totalSpend = 0;
+  let hasEstimates = false;
+  let estimateMargin = 0;
+  const alerts = [];
+  for (const snap of snapshots) {
+    totalSpend += snap.spend;
+    if (snap.isEstimate) {
+      hasEstimates = true;
+      estimateMargin += snap.spend * 0.15;
+    }
+    if (snap.status === "over") {
+      alerts.push({
+        serviceId: snap.serviceId,
+        type: "over_budget",
+        message: `${snap.serviceId.toUpperCase()} ${snap.budgetPercent?.toFixed(0) ?? "?"}% OVER BUDGET \u2014 review before use`,
+        severity: "critical"
+      });
+    } else if (snap.status === "caution" && snap.budgetPercent && snap.budgetPercent >= 80) {
+      alerts.push({
+        serviceId: snap.serviceId,
+        type: "near_budget",
+        message: `${snap.serviceId} at ${snap.budgetPercent.toFixed(0)}% of budget`,
+        severity: "warning"
+      });
+    }
+  }
+  if (blindCount > 0) {
+    alerts.push({
+      serviceId: "_blind",
+      type: "blind_service",
+      message: `${blindCount} service${blindCount > 1 ? "s" : ""} detected but untracked \u2014 run 'burnwatch status' to see`,
+      severity: "warning"
+    });
+  }
+  return {
+    projectName,
+    generatedAt: now.toISOString(),
+    period,
+    services: snapshots,
+    totalSpend,
+    totalIsEstimate: hasEstimates,
+    estimateMargin,
+    untrackedCount: blindCount,
+    alerts
+  };
+}
+function formatRow(service, spend, conf, budget, left, width) {
+  const row = `  ${service.padEnd(14)} ${spend.padEnd(11)} ${conf.padEnd(7)} ${budget.padEnd(7)} ${left}`;
+  return `\u2551${row}`.padEnd(width + 1) + "\u2551";
+}
+function formatLeft(snap) {
+  if (!snap.budget) return "\u2014";
+  if (snap.status === "over") return "\u26A0\uFE0F OVR";
+  if (snap.budgetPercent !== void 0) {
+    const remaining = 100 - snap.budgetPercent;
+    return `${remaining.toFixed(0)}%`;
+  }
+  return "\u2014";
+}
+function buildSnapshot(serviceId, tier, spend, budget) {
+  const isEstimate = tier === "est" || tier === "calc";
+  const budgetPercent = budget ? spend / budget * 100 : void 0;
+  let status = "unknown";
+  let statusLabel = "no budget";
+  if (budget) {
+    if (budgetPercent > 100) {
+      status = "over";
+      statusLabel = `\u26A0\uFE0F ${budgetPercent.toFixed(0)}% over`;
+    } else if (budgetPercent >= 75) {
+      status = "caution";
+      statusLabel = `${(100 - budgetPercent).toFixed(0)}% \u2014 caution`;
+    } else {
+      status = "healthy";
+      statusLabel = `${(100 - budgetPercent).toFixed(0)}% \u2014 healthy`;
+    }
+  }
+  if (tier === "calc" && budget) {
+    statusLabel = `flat \u2014 on plan`;
+    status = "healthy";
+  }
+  return {
+    serviceId,
+    spend,
+    isEstimate,
+    tier,
+    budget,
+    budgetPercent,
+    status,
+    statusLabel,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/core/ledger.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+function writeLedger(brief, projectRoot) {
+  const now = /* @__PURE__ */ new Date();
+  const lines = [];
+  lines.push(`# Burnwatch Ledger \u2014 ${brief.projectName}`);
+  lines.push(`Last updated: ${now.toISOString()}`);
+  lines.push("");
+  lines.push(`## This Month (${brief.period})`);
+  lines.push("");
+  lines.push("| Service | Spend | Conf | Budget | Status |");
+  lines.push("|---------|-------|------|--------|--------|");
+  for (const svc of brief.services) {
+    const spendStr = svc.isEstimate ? `~$${svc.spend.toFixed(2)}` : `$${svc.spend.toFixed(2)}`;
+    const badge = CONFIDENCE_BADGES[svc.tier];
+    const budgetStr = svc.budget ? `$${svc.budget}` : "\u2014";
+    lines.push(
+      `| ${svc.serviceId} | ${spendStr} | ${badge} | ${budgetStr} | ${svc.statusLabel} |`
+    );
+  }
+  lines.push("");
+  const totalStr = brief.totalIsEstimate ? `~$${brief.totalSpend.toFixed(2)}` : `$${brief.totalSpend.toFixed(2)}`;
+  const marginStr = brief.estimateMargin > 0 ? ` (\xB1$${brief.estimateMargin.toFixed(0)} estimated margin)` : "";
+  lines.push(`## TOTAL: ${totalStr}${marginStr}`);
+  lines.push(`## Untracked services: ${brief.untrackedCount}`);
+  lines.push("");
+  if (brief.alerts.length > 0) {
+    lines.push("## Alerts");
+    for (const alert of brief.alerts) {
+      const icon = alert.severity === "critical" ? "\u{1F6A8}" : "\u26A0\uFE0F";
+      lines.push(`- ${icon} ${alert.message}`);
+    }
+    lines.push("");
+  }
+  const ledgerPath = path4.join(
+    projectConfigDir(projectRoot),
+    "spend-ledger.md"
+  );
+  fs4.mkdirSync(path4.dirname(ledgerPath), { recursive: true });
+  fs4.writeFileSync(ledgerPath, lines.join("\n") + "\n", "utf-8");
+}
+function saveSnapshot(brief, projectRoot) {
+  const snapshotDir = path4.join(projectDataDir(projectRoot), "snapshots");
+  fs4.mkdirSync(snapshotDir, { recursive: true });
+  const filename = `snapshot-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`;
+  fs4.writeFileSync(
+    path4.join(snapshotDir, filename),
+    JSON.stringify(brief, null, 2) + "\n",
+    "utf-8"
+  );
+}
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+async function main() {
+  switch (command) {
+    case "init":
+      await cmdInit();
+      break;
+    case "add":
+      await cmdAdd();
+      break;
+    case "status":
+      await cmdStatus();
+      break;
+    case "services":
+      cmdServices();
+      break;
+    case "reconcile":
+      await cmdReconcile();
+      break;
+    case "setup":
+      await cmdSetup();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      cmdHelp();
+      break;
+    case "version":
+    case "--version":
+    case "-v":
+      cmdVersion();
+      break;
+    default:
+      if (command) {
+        console.error(`Unknown command: ${command}`);
+        console.error('Run "burnwatch help" for usage.');
+        process.exit(1);
+      }
+      cmdHelp();
+  }
+}
+async function cmdInit() {
+  const projectRoot = process.cwd();
+  if (isInitialized(projectRoot)) {
+    console.log("\u2705 burnwatch is already initialized in this project.");
+    console.log(`   Config: ${projectConfigDir(projectRoot)}/config.json`);
+    return;
+  }
+  let projectName = path5.basename(projectRoot);
+  try {
+    const pkgPath = path5.join(projectRoot, "package.json");
+    const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+    if (pkg.name) projectName = pkg.name;
+  } catch {
+  }
+  ensureProjectDirs(projectRoot);
+  console.log("\u{1F50D} Scanning project for paid services...\n");
+  const detected = detectServices(projectRoot);
+  const config = {
+    projectName,
+    services: {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  for (const det of detected) {
+    const tracked = {
+      serviceId: det.service.id,
+      detectedVia: det.sources,
+      hasApiKey: false,
+      firstDetected: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    config.services[det.service.id] = tracked;
+  }
+  writeProjectConfig(config, projectRoot);
+  const gitignorePath = path5.join(projectConfigDir(projectRoot), ".gitignore");
+  fs5.writeFileSync(
+    gitignorePath,
+    [
+      "# Burnwatch \u2014 ignore cache and snapshots, keep ledger and config",
+      "data/cache/",
+      "data/snapshots/",
+      "data/events.jsonl",
+      ""
+    ].join("\n"),
+    "utf-8"
+  );
+  if (detected.length === 0) {
+    console.log("   No paid services detected yet.");
+    console.log("   Services will be detected as they enter your project.\n");
+  } else {
+    console.log(`   Found ${detected.length} paid service${detected.length > 1 ? "s" : ""}:
+`);
+    for (const det of detected) {
+      const tierBadge = det.service.apiTier === "live" ? "\u2705 LIVE API available" : det.service.apiTier === "calc" ? "\u{1F7E1} Flat-rate tracking" : det.service.apiTier === "est" ? "\u{1F7E0} Estimate tracking" : "\u{1F534} Detection only";
+      console.log(`   \u2022 ${det.service.name} (${tierBadge})`);
+      console.log(`     Detected via: ${det.details.join(", ")}`);
+    }
+    console.log("");
+  }
+  console.log("\u{1F517} Registering Claude Code hooks...\n");
+  registerHooks(projectRoot);
+  console.log("\u2705 burnwatch initialized!\n");
+  console.log("Next steps:");
+  console.log("  1. Add API keys for LIVE tracking:");
+  console.log("     burnwatch add anthropic --key $ANTHROPIC_ADMIN_KEY --budget 100");
+  console.log("  2. Set budgets for detected services:");
+  console.log("     burnwatch add scrapfly --key $SCRAPFLY_KEY --budget 50");
+  console.log("  3. Check your spend:");
+  console.log("     burnwatch status\n");
+}
+async function cmdAdd() {
+  const projectRoot = process.cwd();
+  if (!isInitialized(projectRoot)) {
+    console.error('\u274C burnwatch not initialized. Run "burnwatch init" first.');
+    process.exit(1);
+  }
+  const serviceId = args[1];
+  if (!serviceId) {
+    console.error("Usage: burnwatch add <service> [--key KEY] [--budget N]");
+    process.exit(1);
+  }
+  const options = {};
+  for (let i = 2; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--") && i + 1 < args.length) {
+      options[arg.slice(2)] = args[i + 1];
+      i++;
+    }
+  }
+  const apiKey = options["key"] ?? options["token"];
+  const budget = options["budget"] ? parseFloat(options["budget"]) : void 0;
+  const planCost = options["plan-cost"] ? parseFloat(options["plan-cost"]) : void 0;
+  const definition = getService(serviceId, projectRoot);
+  if (!definition) {
+    console.error(
+      `\u26A0\uFE0F  "${serviceId}" not found in registry. Adding as custom service.`
+    );
+  }
+  const config = readProjectConfig(projectRoot);
+  const existing = config.services[serviceId];
+  const tracked = {
+    serviceId,
+    detectedVia: existing?.detectedVia ?? ["manual"],
+    budget: budget ?? existing?.budget,
+    hasApiKey: !!apiKey || (existing?.hasApiKey ?? false),
+    planCost: planCost ?? existing?.planCost,
+    firstDetected: existing?.firstDetected ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  config.services[serviceId] = tracked;
+  writeProjectConfig(config, projectRoot);
+  if (apiKey) {
+    const globalConfig = readGlobalConfig();
+    if (!globalConfig.services[serviceId]) {
+      globalConfig.services[serviceId] = {};
+    }
+    globalConfig.services[serviceId].apiKey = apiKey;
+    writeGlobalConfig(globalConfig);
+    console.log(`\u{1F510} API key saved to global config (never stored in project)`);
+  }
+  let tierLabel;
+  if (!definition) {
+    tierLabel = "\u{1F534} BLIND";
+  } else if (apiKey) {
+    tierLabel = "\u2705 LIVE";
+  } else if (planCost !== void 0) {
+    tierLabel = "\u{1F7E1} CALC";
+  } else if (definition.apiTier === "est") {
+    tierLabel = "\u{1F7E0} EST";
+  } else if (definition.apiTier === "calc") {
+    tierLabel = "\u{1F7E1} CALC";
+  } else if (definition.apiTier === "live" && !apiKey) {
+    tierLabel = `\u{1F534} BLIND (add --key for \u2705 LIVE)`;
+  } else {
+    tierLabel = "\u{1F534} BLIND";
+  }
+  console.log(`
+\u2705 ${serviceId} configured:`);
+  console.log(`   Tier: ${tierLabel}`);
+  if (budget) console.log(`   Budget: $${budget}/mo`);
+  if (planCost) console.log(`   Plan cost: $${planCost}/mo`);
+  console.log("");
+}
+async function cmdStatus() {
+  const projectRoot = process.cwd();
+  if (!isInitialized(projectRoot)) {
+    console.error('\u274C burnwatch not initialized. Run "burnwatch init" first.');
+    process.exit(1);
+  }
+  const config = readProjectConfig(projectRoot);
+  const trackedServices = Object.values(config.services);
+  if (trackedServices.length === 0) {
+    console.log("No services tracked yet.");
+    console.log('Run "burnwatch add <service>" to start tracking.');
+    return;
+  }
+  console.log("\u{1F4CA} Polling services...\n");
+  const results = await pollAllServices(trackedServices);
+  const snapshots = results.map(
+    (r) => buildSnapshot(
+      r.serviceId,
+      r.tier,
+      r.spend,
+      config.services[r.serviceId]?.budget
+    )
+  );
+  const blindCount = snapshots.filter((s) => s.tier === "blind").length;
+  const brief = buildBrief(config.projectName, snapshots, blindCount);
+  saveSnapshot(brief, projectRoot);
+  writeLedger(brief, projectRoot);
+  console.log(formatBrief(brief));
+  console.log("");
+  if (blindCount > 0) {
+    console.log(`\u26A0\uFE0F  ${blindCount} service${blindCount > 1 ? "s" : ""} untracked:`);
+    for (const snap of snapshots.filter((s) => s.tier === "blind")) {
+      console.log(
+        `   \u2022 ${snap.serviceId} \u2014 run 'burnwatch add ${snap.serviceId} --key YOUR_KEY --budget N'`
+      );
+    }
+    console.log("");
+  }
+}
+async function cmdSetup() {
+  const projectRoot = process.cwd();
+  if (!isInitialized(projectRoot)) {
+    await cmdInit();
+  }
+  const config = readProjectConfig(projectRoot);
+  const detected = Object.values(config.services);
+  if (detected.length === 0) {
+    console.log("No paid services detected. You're all set!");
+    return;
+  }
+  console.log("\u{1F4CB} Auto-configuring detected services...\n");
+  const globalConfig = readGlobalConfig();
+  const liveServices = [];
+  const calcServices = [];
+  const estServices = [];
+  const blindServices = [];
+  for (const tracked of detected) {
+    const definition = getService(tracked.serviceId, projectRoot);
+    if (!definition) continue;
+    const hasKey = !!globalConfig.services[tracked.serviceId]?.apiKey;
+    if (hasKey && definition.apiTier === "live") {
+      tracked.hasApiKey = true;
+      liveServices.push(`${definition.name}`);
+    } else if (definition.apiTier === "calc") {
+      calcServices.push(`${definition.name}`);
+    } else if (definition.apiTier === "est") {
+      estServices.push(`${definition.name}`);
+    } else {
+      blindServices.push(`${definition.name}`);
+    }
+  }
+  writeProjectConfig(config, projectRoot);
+  if (liveServices.length > 0) {
+    console.log(`  \u2705 LIVE (real billing data): ${liveServices.join(", ")}`);
+  }
+  if (calcServices.length > 0) {
+    console.log(`  \u{1F7E1} CALC (flat-rate tracking): ${calcServices.join(", ")}`);
+  }
+  if (estServices.length > 0) {
+    console.log(`  \u{1F7E0} EST (estimated from usage): ${estServices.join(", ")}`);
+  }
+  if (blindServices.length > 0) {
+    console.log(`  \u{1F534} BLIND (detected, need API key): ${blindServices.join(", ")}`);
+  }
+  console.log("");
+  if (blindServices.length > 0) {
+    console.log("To upgrade BLIND services to LIVE, add API keys:");
+    for (const tracked of detected) {
+      const definition = getService(tracked.serviceId, projectRoot);
+      if (definition?.apiTier === "live" && !tracked.hasApiKey) {
+        const envHint = definition.envPatterns[0] ?? "YOUR_KEY";
+        console.log(`  burnwatch add ${tracked.serviceId} --key $${envHint} --budget <N>`);
+      }
+    }
+    console.log("");
+  }
+  console.log("To set budgets for any service:");
+  console.log("  burnwatch add <service> --budget <monthly_amount>");
+  console.log("");
+  console.log("Or use /setup-burnwatch in Claude Code for guided setup with budget suggestions.\n");
+  await cmdStatus();
+}
+function cmdServices() {
+  const services = getAllServices();
+  console.log(`
+\u{1F4CB} Registry: ${services.length} services available
+`);
+  for (const svc of services) {
+    const tierBadge = svc.apiTier === "live" ? "\u2705 LIVE" : svc.apiTier === "calc" ? "\u{1F7E1} CALC" : svc.apiTier === "est" ? "\u{1F7E0} EST" : "\u{1F534} BLIND";
+    console.log(`  ${svc.name.padEnd(24)} ${tierBadge.padEnd(10)} ${svc.billingModel}`);
+  }
+  console.log("");
+}
+async function cmdReconcile() {
+  const projectRoot = process.cwd();
+  if (!isInitialized(projectRoot)) {
+    console.error('\u274C burnwatch not initialized. Run "burnwatch init" first.');
+    process.exit(1);
+  }
+  console.log("\u{1F50D} Scanning for untracked services and missed sessions...\n");
+  const detected = detectServices(projectRoot);
+  const config = readProjectConfig(projectRoot);
+  let newCount = 0;
+  for (const det of detected) {
+    if (!config.services[det.service.id]) {
+      config.services[det.service.id] = {
+        serviceId: det.service.id,
+        detectedVia: det.sources,
+        hasApiKey: false,
+        firstDetected: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      newCount++;
+      console.log(`  \u{1F195} ${det.service.name} \u2014 detected via ${det.details.join(", ")}`);
+    }
+  }
+  if (newCount > 0) {
+    writeProjectConfig(config, projectRoot);
+    console.log(
+      `
+\u2705 Found ${newCount} new service${newCount > 1 ? "s" : ""}. Run 'burnwatch status' to see updated brief.`
+    );
+  } else {
+    console.log("  \u2705 No new services found. All services already tracked.");
+  }
+  console.log("");
+}
+function cmdHelp() {
+  console.log(`
+burnwatch \u2014 Passive cost memory for vibe coding
+
+Usage:
+  burnwatch init                              Initialize in current project
+  burnwatch setup                             Init + auto-configure all detected services
+  burnwatch add <service> [options]           Register a service for tracking
+  burnwatch status                            Show current spend brief
+  burnwatch services                          List all services in registry
+  burnwatch reconcile                         Scan for untracked services
+
+Options for 'add':
+  --key <API_KEY>        API key for LIVE tracking (saved to ~/.config/burnwatch/)
+  --token <TOKEN>        Same as --key (alias)
+  --budget <AMOUNT>      Monthly budget in USD
+  --plan-cost <AMOUNT>   Monthly plan cost for CALC tracking
+
+Examples:
+  burnwatch init
+  burnwatch add anthropic --key sk-ant-admin-xxx --budget 100
+  burnwatch add scrapfly --key scp-xxx --budget 50
+  burnwatch add posthog --plan-cost 0 --budget 0
+  burnwatch status
+`);
+}
+function cmdVersion() {
+  try {
+    const pkgPath = path5.resolve(
+      path5.dirname(new URL(import.meta.url).pathname),
+      "../package.json"
+    );
+    const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+    console.log(`burnwatch v${pkg.version}`);
+  } catch {
+    console.log("burnwatch v0.1.0");
+  }
+}
+function registerHooks(projectRoot) {
+  const claudeDir = path5.join(projectRoot, ".claude");
+  const settingsPath = path5.join(claudeDir, "settings.json");
+  fs5.mkdirSync(claudeDir, { recursive: true });
+  let settings = {};
+  try {
+    settings = JSON.parse(fs5.readFileSync(settingsPath, "utf-8"));
+  } catch {
+  }
+  const hookBase = `node "${path5.join(projectRoot, "node_modules", "burnwatch", "dist", "hooks")}"`;
+  const useNpx = !fs5.existsSync(
+    path5.join(projectRoot, "node_modules", "burnwatch")
+  );
+  const prefix = useNpx ? "npx --yes burnwatch-hook" : hookBase;
+  const hooksDir = path5.resolve(
+    path5.dirname(new URL(import.meta.url).pathname),
+    "hooks"
+  );
+  const hooks = settings["hooks"] ?? {};
+  if (!hooks["SessionStart"]) hooks["SessionStart"] = [];
+  addHookIfMissing(hooks["SessionStart"], "SessionStart", {
+    matcher: "startup|resume",
+    hooks: [
+      {
+        type: "command",
+        command: `node "${path5.join(hooksDir, "on-session-start.js")}"`,
+        timeout: 15
+      }
+    ]
+  });
+  if (!hooks["UserPromptSubmit"]) hooks["UserPromptSubmit"] = [];
+  addHookIfMissing(
+    hooks["UserPromptSubmit"],
+    "UserPromptSubmit",
+    {
+      hooks: [
+        {
+          type: "command",
+          command: `node "${path5.join(hooksDir, "on-prompt.js")}"`,
+          timeout: 5
+        }
+      ]
+    }
+  );
+  if (!hooks["PostToolUse"]) hooks["PostToolUse"] = [];
+  addHookIfMissing(hooks["PostToolUse"], "PostToolUse", {
+    matcher: "Edit|Write",
+    hooks: [
+      {
+        type: "command",
+        command: `node "${path5.join(hooksDir, "on-file-change.js")}"`,
+        timeout: 5
+      }
+    ]
+  });
+  if (!hooks["Stop"]) hooks["Stop"] = [];
+  addHookIfMissing(hooks["Stop"], "Stop", {
+    hooks: [
+      {
+        type: "command",
+        command: `node "${path5.join(hooksDir, "on-stop.js")}"`,
+        timeout: 15,
+        async: true
+      }
+    ]
+  });
+  settings["hooks"] = hooks;
+  fs5.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  console.log(`   Hooks registered in ${settingsPath}`);
+}
+function addHookIfMissing(hookArray, _eventName, hookConfig) {
+  const existing = hookArray.some((h) => {
+    const hook = h;
+    return hook.hooks?.some((inner) => inner.command?.includes("burnwatch"));
+  });
+  if (!existing) {
+    hookArray.push(hookConfig);
+  }
+}
+main().catch((err) => {
+  console.error("Error:", err instanceof Error ? err.message : err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map