burnwatch 0.1.0

package/dist/hooks/on-session-start.js

@@ -0,0 +1,766 @@
+#!/usr/bin/env node
+
+// src/hooks/on-session-start.ts
+import * as fs5 from "fs";
+
+// 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 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 isInitialized(projectRoot) {
+  return readProjectConfig(projectRoot) !== null;
+}
+
+// src/core/ledger.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/core/types.ts
+var CONFIDENCE_BADGES = {
+  live: "\u2705 LIVE",
+  calc: "\u{1F7E1} CALC",
+  est: "\u{1F7E0} EST",
+  blind: "\u{1F534} BLIND"
+};
+
+// src/core/ledger.ts
+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 = path2.join(
+    projectConfigDir(projectRoot),
+    "spend-ledger.md"
+  );
+  fs2.mkdirSync(path2.dirname(ledgerPath), { recursive: true });
+  fs2.writeFileSync(ledgerPath, lines.join("\n") + "\n", "utf-8");
+}
+function logEvent(event, projectRoot) {
+  const logPath = path2.join(projectDataDir(projectRoot), "events.jsonl");
+  fs2.mkdirSync(path2.dirname(logPath), { recursive: true });
+  fs2.appendFileSync(logPath, JSON.stringify(event) + "\n", "utf-8");
+}
+function saveSnapshot(brief, projectRoot) {
+  const snapshotDir = path2.join(projectDataDir(projectRoot), "snapshots");
+  fs2.mkdirSync(snapshotDir, { recursive: true });
+  const filename = `snapshot-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`;
+  fs2.writeFileSync(
+    path2.join(snapshotDir, filename),
+    JSON.stringify(brief, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function readLatestSnapshot(projectRoot) {
+  const snapshotDir = path2.join(projectDataDir(projectRoot), "snapshots");
+  try {
+    const files = fs2.readdirSync(snapshotDir).filter((f) => f.startsWith("snapshot-") && f.endsWith(".json")).sort().reverse();
+    if (files.length === 0) return null;
+    const raw = fs2.readFileSync(
+      path2.join(snapshotDir, files[0]),
+      "utf-8"
+    );
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// 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/detection/detector.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+
+// src/core/registry.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as url from "url";
+var __dirname = path3.dirname(url.fileURLToPath(import.meta.url));
+var cachedRegistry = null;
+function loadRegistry(projectRoot) {
+  if (cachedRegistry) return cachedRegistry;
+  const registry = /* @__PURE__ */ new Map();
+  const candidates = [
+    path3.resolve(__dirname, "../../registry.json"),
+    // from src/core/
+    path3.resolve(__dirname, "../registry.json")
+    // from dist/
+  ];
+  for (const candidate of candidates) {
+    if (fs3.existsSync(candidate)) {
+      loadRegistryFile(candidate, registry);
+      break;
+    }
+  }
+  if (projectRoot) {
+    const localPath = path3.join(projectRoot, ".burnwatch", "registry.json");
+    if (fs3.existsSync(localPath)) {
+      loadRegistryFile(localPath, registry);
+    }
+  }
+  cachedRegistry = registry;
+  return registry;
+}
+function loadRegistryFile(filePath, registry) {
+  try {
+    const raw = fs3.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);
+}
+
+// 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 = path4.join(projectRoot, "package.json");
+  try {
+    const raw = fs4.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 = path4.join(projectRoot, "src");
+  if (!fs4.existsSync(srcDir)) return imports;
+  const files = walkDir(srcDir, /\.(ts|tsx|js|jsx|mjs|cjs)$/);
+  for (const file of files) {
+    try {
+      const content = fs4.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 = fs4.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const fullPath = path4.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/hooks/on-session-start.ts
+async function main() {
+  let input;
+  try {
+    const stdin = fs5.readFileSync(0, "utf-8");
+    input = JSON.parse(stdin);
+  } catch {
+    process.exit(0);
+    return;
+  }
+  const projectRoot = input.cwd;
+  if (!isInitialized(projectRoot)) {
+    process.exit(0);
+    return;
+  }
+  const config = readProjectConfig(projectRoot);
+  const cachedBrief = readLatestSnapshot(projectRoot);
+  let briefText;
+  if (cachedBrief) {
+    briefText = formatBrief(cachedBrief);
+  } else {
+    const detected = detectServices(projectRoot);
+    const snapshots = Object.values(config.services).map((tracked) => {
+      return buildSnapshot(
+        tracked.serviceId,
+        tracked.hasApiKey ? "live" : "blind",
+        tracked.planCost ?? 0,
+        tracked.budget
+      );
+    });
+    for (const det of detected) {
+      if (!config.services[det.service.id]) {
+        snapshots.push(
+          buildSnapshot(det.service.id, "blind", 0, void 0)
+        );
+      }
+    }
+    const blindCount = snapshots.filter((s) => s.tier === "blind").length;
+    const brief = buildBrief(config.projectName, snapshots, blindCount);
+    briefText = formatBrief(brief);
+  }
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: briefText
+    }
+  };
+  process.stdout.write(JSON.stringify(output));
+  logEvent(
+    {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: input.session_id,
+      type: "session_start",
+      data: { source: input.source }
+    },
+    projectRoot
+  );
+  try {
+    const trackedServices = Object.values(config.services);
+    if (trackedServices.length > 0) {
+      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);
+    }
+  } catch {
+  }
+}
+main().catch(() => process.exit(0));
+//# sourceMappingURL=on-session-start.js.map