burnwatch 0.1.2 → 0.3.0

package/dist/mcp-server.js

@@ -0,0 +1,934 @@
+#!/usr/bin/env node
+
+// src/mcp-server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// 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 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/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/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);
+}
+function getAllServices(projectRoot) {
+  return Array.from(loadRegistry(projectRoot).values());
+}
+
+// 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/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 formatSpendCard(snapshot) {
+  const badge = CONFIDENCE_BADGES[snapshot.tier];
+  const spendStr = snapshot.isEstimate ? `~$${snapshot.spend.toFixed(2)}` : `$${snapshot.spend.toFixed(2)}`;
+  const budgetStr = snapshot.budget ? `Budget: $${snapshot.budget}` : "No budget set";
+  const statusStr = snapshot.statusLabel;
+  const lines = [
+    `[BURNWATCH] ${snapshot.serviceId} \u2014 current period`,
+    `  Spend: ${spendStr}  |  ${budgetStr}  |  ${statusStr}`,
+    `  Confidence: ${badge}`
+  ];
+  if (snapshot.status === "over" && snapshot.budgetPercent) {
+    lines.push(
+      `  \u26A0\uFE0F ${snapshot.budgetPercent.toFixed(0)}% of budget consumed`
+    );
+  }
+  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";
+function detectServices(projectRoot) {
+  const registry = loadRegistry(projectRoot);
+  const results = /* @__PURE__ */ new Map();
+  const pkgDeps = scanAllPackageJsons(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 = collectEnvVars(projectRoot);
+  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 scanAllPackageJsons(projectRoot) {
+  const deps = /* @__PURE__ */ new Set();
+  const pkgFiles = findFiles(projectRoot, "package.json", 4);
+  for (const pkgPath of pkgFiles) {
+    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 collectEnvVars(projectRoot) {
+  const envVars = new Set(Object.keys(process.env));
+  const envFiles = findEnvFiles(projectRoot, 3);
+  for (const envFile of envFiles) {
+    try {
+      const content = fs4.readFileSync(envFile, "utf-8");
+      const keys = content.split("\n").filter((line) => line.includes("=") && !line.startsWith("#")).map((line) => line.split("=")[0].trim()).filter(Boolean);
+      for (const key of keys) {
+        envVars.add(key);
+      }
+    } catch {
+    }
+  }
+  return envVars;
+}
+function findEnvFiles(dir, maxDepth) {
+  const results = [];
+  if (maxDepth <= 0) return results;
+  try {
+    const entries = fs4.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") continue;
+      const fullPath = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findEnvFiles(fullPath, maxDepth - 1));
+      } else if (entry.name.startsWith(".env")) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function findFiles(dir, fileName, maxDepth) {
+  const results = [];
+  if (maxDepth <= 0) return results;
+  try {
+    const entries = fs4.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") continue;
+      const fullPath = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findFiles(fullPath, fileName, maxDepth - 1));
+      } else if (entry.name === fileName) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function scanImports(projectRoot) {
+  const imports = /* @__PURE__ */ new Set();
+  const codeDirs = ["src", "app", "lib", "pages", "components", "utils", "services", "hooks"];
+  const dirsToScan = [];
+  for (const dir of codeDirs) {
+    const fullPath = path4.join(projectRoot, dir);
+    if (fs4.existsSync(fullPath)) {
+      dirsToScan.push(fullPath);
+    }
+  }
+  try {
+    const entries = fs4.readdirSync(projectRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist" || entry.name.startsWith(".")) continue;
+      const subPkgPath = path4.join(projectRoot, entry.name, "package.json");
+      if (fs4.existsSync(subPkgPath)) {
+        for (const dir of codeDirs) {
+          const fullPath = path4.join(projectRoot, entry.name, dir);
+          if (fs4.existsSync(fullPath)) {
+            dirsToScan.push(fullPath);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  for (const dir of dirsToScan) {
+    const files = walkDir(dir, /\.(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/mcp-server.ts
+var server = new McpServer({
+  name: "burnwatch",
+  version: "0.1.2"
+});
+server.tool(
+  "get_spend_brief",
+  "Get the current spend brief for this project. Shows all tracked services, their spend, confidence tier, budget status, and alerts. Use this when a developer asks about costs, spending, budget, or wants an overview of their SaaS expenses.",
+  {
+    project_path: z.string().optional().describe(
+      "Path to the project root. Defaults to current working directory."
+    )
+  },
+  async ({ project_path }) => {
+    const projectRoot = project_path ?? process.cwd();
+    if (!isInitialized(projectRoot)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "burnwatch is not initialized in this project. Run `npx burnwatch init` to set up spend tracking."
+          }
+        ]
+      };
+    }
+    const config = readProjectConfig(projectRoot);
+    const trackedServices = Object.values(config.services);
+    if (trackedServices.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No services are being tracked yet. Run `burnwatch add <service>` to start tracking."
+          }
+        ]
+      };
+    }
+    const cached = readLatestSnapshot(projectRoot);
+    if (cached) {
+      return {
+        content: [
+          { type: "text", text: formatBrief(cached) }
+        ]
+      };
+    }
+    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);
+    return {
+      content: [{ type: "text", text: formatBrief(brief) }]
+    };
+  }
+);
+server.tool(
+  "get_service_spend",
+  "Get detailed spend information for a specific service. Includes current spend, budget status, confidence tier, pricing model, gotchas, and cheaper alternatives. Use this when a developer mentions a specific paid service or asks about its cost.",
+  {
+    service_id: z.string().describe(
+      "The service identifier (e.g., 'anthropic', 'scrapfly', 'vercel', 'supabase')"
+    ),
+    project_path: z.string().optional().describe("Path to the project root. Defaults to cwd.")
+  },
+  async ({ service_id, project_path }) => {
+    const projectRoot = project_path ?? process.cwd();
+    const definition = getService(service_id, projectRoot);
+    if (!definition) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Service "${service_id}" not found in the burnwatch registry. Run \`burnwatch services\` to see available services.`
+          }
+        ]
+      };
+    }
+    const lines = [];
+    lines.push(`## ${definition.name}`);
+    lines.push("");
+    if (isInitialized(projectRoot)) {
+      const snapshot = readLatestSnapshot(projectRoot);
+      const serviceSnap = snapshot?.services.find(
+        (s) => s.serviceId === service_id
+      );
+      if (serviceSnap) {
+        lines.push(formatSpendCard(serviceSnap));
+        lines.push("");
+      }
+    }
+    lines.push(`**Billing model:** ${definition.billingModel}`);
+    lines.push(`**Scaling:** ${definition.scalingShape}`);
+    lines.push(
+      `**Tracking tier:** ${definition.apiTier.toUpperCase()}`
+    );
+    if (definition.pricing?.formula) {
+      lines.push(`**Pricing formula:** ${definition.pricing.formula}`);
+    }
+    if (definition.gotchas && definition.gotchas.length > 0) {
+      lines.push("");
+      lines.push("**Cost gotchas:**");
+      for (const g of definition.gotchas) {
+        lines.push(`- ${g}`);
+      }
+    }
+    if (definition.alternatives && definition.alternatives.length > 0) {
+      lines.push("");
+      lines.push(
+        `**Cheaper alternatives:** ${definition.alternatives.join(", ")}`
+      );
+    }
+    if (definition.docsUrl) {
+      lines.push("");
+      lines.push(`**Pricing docs:** ${definition.docsUrl}`);
+    }
+    return {
+      content: [{ type: "text", text: lines.join("\n") }]
+    };
+  }
+);
+server.tool(
+  "detect_paid_services",
+  "Scan a project for paid services. Detects services via package.json dependencies, environment variables, and import statements. Use this when a developer wants to know what paid services are in their project, or before recommending a new paid tool.",
+  {
+    project_path: z.string().optional().describe("Path to the project root. Defaults to cwd.")
+  },
+  async ({ project_path }) => {
+    const projectRoot = project_path ?? process.cwd();
+    const detected = detectServices(projectRoot);
+    if (detected.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No paid services detected in this project."
+          }
+        ]
+      };
+    }
+    const lines = [];
+    lines.push(
+      `Found ${detected.length} paid service${detected.length > 1 ? "s" : ""}:`
+    );
+    lines.push("");
+    for (const det of detected) {
+      const tierLabel = det.service.apiTier === "live" ? "\u2705 LIVE" : det.service.apiTier === "calc" ? "\u{1F7E1} CALC" : det.service.apiTier === "est" ? "\u{1F7E0} EST" : "\u{1F534} BLIND";
+      lines.push(
+        `- **${det.service.name}** (${tierLabel}) \u2014 ${det.details.join(", ")}`
+      );
+      if (det.service.gotchas && det.service.gotchas.length > 0) {
+        lines.push(`  \u26A0\uFE0F ${det.service.gotchas[0]}`);
+      }
+    }
+    lines.push("");
+    lines.push(
+      "Run `npx burnwatch init` to start tracking spend for all detected services."
+    );
+    return {
+      content: [{ type: "text", text: lines.join("\n") }]
+    };
+  }
+);
+server.tool(
+  "list_registry_services",
+  "List all services in the burnwatch registry with their tracking tier and billing model. Use this to see what services burnwatch can track.",
+  {},
+  async () => {
+    const services = getAllServices();
+    const lines = [];
+    lines.push(`burnwatch registry: ${services.length} services`);
+    lines.push("");
+    lines.push("| Service | Tier | Billing Model |");
+    lines.push("|---------|------|--------------|");
+    for (const svc of services) {
+      const tier = svc.apiTier === "live" ? "\u2705 LIVE" : svc.apiTier === "calc" ? "\u{1F7E1} CALC" : svc.apiTier === "est" ? "\u{1F7E0} EST" : "\u{1F534} BLIND";
+      lines.push(`| ${svc.name} | ${tier} | ${svc.billingModel} |`);
+    }
+    return {
+      content: [{ type: "text", text: lines.join("\n") }]
+    };
+  }
+);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("burnwatch MCP server running on stdio");
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=mcp-server.js.map