squads-cli 0.2.0 → 0.2.1

package/dist/chunk-WVOIY5GW.js

@@ -0,0 +1,621 @@
+#!/usr/bin/env node
+import {
+  calcCost,
+  detectProviderFromModel,
+  detectProvidersFromEnv,
+  getProviderDisplayName
+} from "./chunk-LOA3KWYJ.js";
+import {
+  getEnv
+} from "./chunk-EHQJHRIW.js";
+
+// src/lib/plan.ts
+function detectPlan() {
+  const explicitPlan = process.env.SQUADS_PLAN_TYPE?.toLowerCase();
+  if (explicitPlan === "usage") {
+    return { plan: "usage", confidence: "explicit", reason: "SQUADS_PLAN_TYPE=usage" };
+  }
+  if (explicitPlan === "max") {
+    return { plan: "max", confidence: "explicit", reason: "SQUADS_PLAN_TYPE=max" };
+  }
+  const budgetSet = process.env.ANTHROPIC_BUDGET_DAILY || process.env.SQUADS_DAILY_BUDGET;
+  if (budgetSet) {
+    return { plan: "usage", confidence: "inferred", reason: `Budget set ($${budgetSet}/day)` };
+  }
+  const tier = parseInt(process.env.ANTHROPIC_TIER || "0", 10);
+  if (tier >= 4) {
+    return { plan: "max", confidence: "inferred", reason: `Tier ${tier} (high usage)` };
+  }
+  if (tier >= 1 && tier <= 2) {
+    return { plan: "usage", confidence: "inferred", reason: `Tier ${tier} (new user)` };
+  }
+  if (!process.env.ANTHROPIC_API_KEY) {
+    return { plan: "max", confidence: "inferred", reason: "OAuth (Claude Code subscription)" };
+  }
+  return { plan: "usage", confidence: "inferred", reason: "API key (pay-per-token)" };
+}
+function getPlanType() {
+  return detectPlan().plan;
+}
+function isMaxPlan() {
+  return getPlanType() === "max";
+}
+
+// src/lib/costs.ts
+var DEFAULT_DAILY_BUDGET = 200;
+var DEFAULT_DAILY_CALL_LIMIT = 1e3;
+var BRIDGE_URL = getEnv().bridge_url;
+var FETCH_TIMEOUT_MS = 2e3;
+async function fetchWithTimeout(url, options = {}, timeoutMs = FETCH_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { ...options, signal: controller.signal });
+    clearTimeout(timeoutId);
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw error;
+  }
+}
+function calcCost2(model, inputTokens, outputTokens) {
+  const provider = detectProviderFromModel(model);
+  return calcCost(provider, model, inputTokens, outputTokens);
+}
+async function fetchFromBridge(period = "day") {
+  try {
+    const response = await fetchWithTimeout(`${BRIDGE_URL}/api/cost/summary?period=${period}`, {
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    const dailyBudget = parseFloat(process.env.SQUADS_DAILY_BUDGET || "") || DEFAULT_DAILY_BUDGET;
+    const totalCost = data.totals?.cost_usd || 0;
+    const bySquad = (data.by_squad || []).map((s) => ({
+      squad: s.squad,
+      calls: s.generations || 0,
+      inputTokens: s.input_tokens || 0,
+      outputTokens: s.output_tokens || 0,
+      cachedTokens: s.cached_tokens || 0,
+      cost: s.cost_usd || 0,
+      models: {}
+    }));
+    const totalCalls = bySquad.reduce((sum, s) => sum + s.calls, 0);
+    const dailyCallLimit = parseFloat(process.env.SQUADS_DAILY_CALL_LIMIT || "") || DEFAULT_DAILY_CALL_LIMIT;
+    const totalCachedTokens = bySquad.reduce((sum, s) => sum + s.cachedTokens, 0);
+    const totalInputTokens = bySquad.reduce((sum, s) => sum + s.inputTokens, 0);
+    const totalAllInput = totalInputTokens + totalCachedTokens;
+    const cacheHitRate = totalAllInput > 0 ? totalCachedTokens / totalAllInput * 100 : 0;
+    const detectedProviders = detectProvidersFromEnv();
+    const byProvider = detectedProviders.map((p) => ({
+      provider: p.provider,
+      displayName: getProviderDisplayName(p.provider),
+      calls: 0,
+      // Bridge doesn't track by provider yet
+      inputTokens: 0,
+      outputTokens: 0,
+      cost: p.provider === "anthropic" ? totalCost : 0,
+      // Assume all cost is Anthropic for now
+      plan: p.plan,
+      confidence: p.confidence,
+      reason: p.reason
+    }));
+    return {
+      totalCost,
+      dailyBudget,
+      usedPercent: totalCost / dailyBudget * 100,
+      idleBudget: dailyBudget - totalCost,
+      totalCalls,
+      dailyCallLimit,
+      callsPercent: totalCalls / dailyCallLimit * 100,
+      totalCachedTokens,
+      totalInputTokens,
+      cacheHitRate,
+      bySquad,
+      byProvider,
+      source: "postgres"
+    };
+  } catch {
+    return null;
+  }
+}
+async function fetchFromLangfuse(limit = 100) {
+  const publicKey = process.env.LANGFUSE_PUBLIC_KEY;
+  const secretKey = process.env.LANGFUSE_SECRET_KEY;
+  const host = process.env.LANGFUSE_HOST || process.env.LANGFUSE_BASE_URL || "https://us.cloud.langfuse.com";
+  if (!publicKey || !secretKey) {
+    return null;
+  }
+  try {
+    const auth = Buffer.from(`${publicKey}:${secretKey}`).toString("base64");
+    const url = `${host}/api/public/observations?limit=${limit}`;
+    const response = await fetchWithTimeout(url, {
+      headers: {
+        Authorization: `Basic ${auth}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    const observations = data.data || [];
+    const bySquad = {};
+    for (const obs of observations) {
+      if (obs.type !== "GENERATION") continue;
+      const metadata = obs.metadata || {};
+      const squad = metadata.squad || "unknown";
+      const model = obs.model || "unknown";
+      const usage = obs.usage || {};
+      const inputTokens = usage.input || 0;
+      const outputTokens = usage.output || 0;
+      const cost = calcCost2(model, inputTokens, outputTokens);
+      if (!bySquad[squad]) {
+        bySquad[squad] = {
+          squad,
+          calls: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cachedTokens: 0,
+          cost: 0,
+          models: {}
+        };
+      }
+      bySquad[squad].calls += 1;
+      bySquad[squad].inputTokens += inputTokens;
+      bySquad[squad].outputTokens += outputTokens;
+      bySquad[squad].cost += cost;
+      bySquad[squad].models[model] = (bySquad[squad].models[model] || 0) + 1;
+    }
+    const squadList = Object.values(bySquad).sort((a, b) => b.cost - a.cost);
+    const totalCost = squadList.reduce((sum, s) => sum + s.cost, 0);
+    const dailyBudget = parseFloat(process.env.SQUADS_DAILY_BUDGET || "") || DEFAULT_DAILY_BUDGET;
+    const totalCalls = squadList.reduce((sum, s) => sum + s.calls, 0);
+    const dailyCallLimit = parseFloat(process.env.SQUADS_DAILY_CALL_LIMIT || "") || DEFAULT_DAILY_CALL_LIMIT;
+    const totalCachedTokens = squadList.reduce((sum, s) => sum + s.cachedTokens, 0);
+    const totalInputTokens = squadList.reduce((sum, s) => sum + s.inputTokens, 0);
+    const totalAllInput = totalInputTokens + totalCachedTokens;
+    const cacheHitRate = totalAllInput > 0 ? totalCachedTokens / totalAllInput * 100 : 0;
+    const providerMap = {};
+    for (const obs of observations) {
+      if (obs.type !== "GENERATION") continue;
+      const model = obs.model || "unknown";
+      const provider = detectProviderFromModel(model);
+      const usage = obs.usage || {};
+      const inputTokens = usage.input || 0;
+      const outputTokens = usage.output || 0;
+      const cost = calcCost2(model, inputTokens, outputTokens);
+      if (!providerMap[provider]) {
+        const detection = detectProvidersFromEnv().find((p) => p.provider === provider);
+        providerMap[provider] = {
+          provider,
+          displayName: getProviderDisplayName(provider),
+          calls: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cost: 0,
+          plan: detection?.plan,
+          confidence: detection?.confidence,
+          reason: detection?.reason
+        };
+      }
+      providerMap[provider].calls += 1;
+      providerMap[provider].inputTokens += inputTokens;
+      providerMap[provider].outputTokens += outputTokens;
+      providerMap[provider].cost += cost;
+    }
+    const byProvider = Object.values(providerMap).sort((a, b) => b.cost - a.cost);
+    return {
+      totalCost,
+      dailyBudget,
+      usedPercent: totalCost / dailyBudget * 100,
+      idleBudget: dailyBudget - totalCost,
+      totalCalls,
+      dailyCallLimit,
+      callsPercent: totalCalls / dailyCallLimit * 100,
+      totalCachedTokens,
+      totalInputTokens,
+      cacheHitRate,
+      bySquad: squadList,
+      byProvider,
+      source: "langfuse"
+    };
+  } catch {
+    return null;
+  }
+}
+async function fetchCostSummary(limit = 100, period = "day") {
+  const bridgeResult = await fetchFromBridge(period);
+  if (bridgeResult) {
+    return bridgeResult;
+  }
+  const langfuseResult = await fetchFromLangfuse(limit);
+  if (langfuseResult) {
+    return langfuseResult;
+  }
+  const defaultBudget = parseFloat(process.env.SQUADS_DAILY_BUDGET || "") || DEFAULT_DAILY_BUDGET;
+  const detectedProviders = detectProvidersFromEnv();
+  const byProvider = detectedProviders.map((p) => ({
+    provider: p.provider,
+    displayName: getProviderDisplayName(p.provider),
+    calls: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cost: 0,
+    plan: p.plan,
+    confidence: p.confidence,
+    reason: p.reason
+  }));
+  return {
+    totalCost: 0,
+    dailyBudget: defaultBudget,
+    usedPercent: 0,
+    idleBudget: defaultBudget,
+    totalCalls: 0,
+    dailyCallLimit: DEFAULT_DAILY_CALL_LIMIT,
+    callsPercent: 0,
+    totalCachedTokens: 0,
+    totalInputTokens: 0,
+    cacheHitRate: 0,
+    bySquad: [],
+    byProvider,
+    source: "none"
+  };
+}
+async function fetchBridgeStats() {
+  try {
+    const [statsResponse, healthResponse, costResponse, weekResponse] = await Promise.all([
+      fetchWithTimeout(`${BRIDGE_URL}/stats`, {
+        headers: { "Content-Type": "application/json" }
+      }),
+      fetchWithTimeout(`${BRIDGE_URL}/health`, {
+        headers: { "Content-Type": "application/json" }
+      }),
+      fetchWithTimeout(`${BRIDGE_URL}/api/cost/summary?period=day`, {
+        headers: { "Content-Type": "application/json" }
+      }),
+      fetchWithTimeout(`${BRIDGE_URL}/api/cost/summary?period=week`, {
+        headers: { "Content-Type": "application/json" }
+      })
+    ]);
+    if (!statsResponse.ok) {
+      return null;
+    }
+    const [stats, health, costData, weekData] = await Promise.all([
+      statsResponse.json(),
+      healthResponse.ok ? healthResponse.json() : Promise.resolve({}),
+      costResponse.ok ? costResponse.json() : Promise.resolve({}),
+      weekResponse.ok ? weekResponse.json() : Promise.resolve({})
+    ]);
+    return {
+      status: stats.status || "unknown",
+      source: stats.source || "none",
+      today: {
+        generations: stats.today?.generations || 0,
+        inputTokens: stats.today?.input_tokens || 0,
+        outputTokens: stats.today?.output_tokens || 0,
+        costUsd: stats.today?.cost_usd || 0
+      },
+      week: weekData.totals ? {
+        generations: weekData.totals.generations || 0,
+        inputTokens: weekData.totals.input_tokens || 0,
+        outputTokens: weekData.totals.output_tokens || 0,
+        costUsd: weekData.totals.cost_usd || 0,
+        byModel: (weekData.by_model || []).map((m) => ({
+          model: m.model || "unknown",
+          generations: m.generations || 0,
+          costUsd: m.cost_usd || 0
+        }))
+      } : void 0,
+      budget: {
+        daily: stats.budget?.daily || DEFAULT_DAILY_BUDGET,
+        used: stats.budget?.used || 0,
+        remaining: stats.budget?.remaining || DEFAULT_DAILY_BUDGET,
+        usedPct: stats.budget?.used_pct || 0
+      },
+      bySquad: (stats.by_squad || []).map((s) => ({
+        squad: s.squad || "unknown",
+        costUsd: s.cost_usd || 0,
+        generations: s.generations || 0
+      })),
+      byModel: (costData.by_model || []).map((m) => ({
+        model: m.model || "unknown",
+        generations: m.generations || 0,
+        costUsd: m.cost_usd || 0
+      })),
+      health: {
+        postgres: health.postgres || "unknown",
+        redis: health.redis || "unknown",
+        langfuse: health.langfuse || "unknown"
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+async function fetchQuotaInfo() {
+  try {
+    const response = await fetchWithTimeout(`${BRIDGE_URL}/api/autonomy/score`);
+    if (!response.ok) return null;
+    const data = await response.json();
+    return {
+      monthlyUsed: data.execution_stats.monthly_used,
+      monthlyQuota: data.execution_stats.monthly_quota,
+      quotaPct: data.execution_stats.quota_pct,
+      autonomyScore: data.overall_score,
+      confidenceLevel: data.confidence_level,
+      learningCount: data.execution_stats.learning_count
+    };
+  } catch {
+    return null;
+  }
+}
+async function fetchRateLimits() {
+  try {
+    const response = await fetchWithTimeout(`${BRIDGE_URL}/api/rate-limits`, {
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      return { limits: {}, source: "none" };
+    }
+    const data = await response.json();
+    const rateLimits = data.rate_limits || {};
+    const limits = {};
+    for (const [key, value] of Object.entries(rateLimits)) {
+      limits[key] = {
+        model: value.model || key,
+        requestsLimit: value.requests_limit || 0,
+        requestsRemaining: value.requests_remaining || 0,
+        requestsReset: value.requests_reset,
+        tokensLimit: value.tokens_limit || 0,
+        tokensRemaining: value.tokens_remaining || 0,
+        tokensReset: value.tokens_reset,
+        inputTokensLimit: value.input_tokens_limit,
+        inputTokensRemaining: value.input_tokens_remaining,
+        outputTokensLimit: value.output_tokens_limit,
+        outputTokensRemaining: value.output_tokens_remaining,
+        capturedAt: value.captured_at || (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    return { limits, source: "proxy" };
+  } catch {
+    return { limits: {}, source: "none" };
+  }
+}
+async function fetchInsights(period = "week") {
+  try {
+    const response = await fetchWithTimeout(`${BRIDGE_URL}/api/insights?period=${period}`, {
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      return {
+        period,
+        days: period === "day" ? 1 : period === "week" ? 7 : 30,
+        taskMetrics: [],
+        qualityMetrics: [],
+        topTools: [],
+        toolFailureRate: 0,
+        source: "none"
+      };
+    }
+    const data = await response.json();
+    return {
+      period: data.period || period,
+      days: data.days || 7,
+      taskMetrics: (data.task_metrics || []).map((t) => ({
+        squad: t.squad,
+        tasksTotal: t.tasks_total || 0,
+        tasksCompleted: t.tasks_completed || 0,
+        tasksFailed: t.tasks_failed || 0,
+        successRate: t.success_rate || 0,
+        totalRetries: t.total_retries || 0,
+        tasksWithRetries: t.tasks_with_retries || 0,
+        avgRetries: t.avg_retries || 0,
+        avgDurationMs: t.avg_duration_ms || 0,
+        avgTokens: t.avg_tokens || 0,
+        avgCost: t.avg_cost || 0,
+        avgContextPct: t.avg_context_pct || 0,
+        maxContextTokens: t.max_context_tokens || 0
+      })),
+      qualityMetrics: (data.quality_metrics || []).map((q) => ({
+        squad: q.squad,
+        feedbackCount: q.feedback_count || 0,
+        avgQuality: q.avg_quality || 0,
+        helpfulPct: q.helpful_pct || 0,
+        fixRequiredPct: q.fix_required_pct || 0
+      })),
+      topTools: (data.top_tools || []).map((t) => ({
+        toolName: t.tool_name,
+        usageCount: t.usage_count || 0,
+        successRate: t.success_rate || 0,
+        avgDurationMs: t.avg_duration_ms || 0
+      })),
+      toolFailureRate: data.tool_failure_rate || 0,
+      source: "bridge"
+    };
+  } catch {
+    return {
+      period,
+      days: period === "day" ? 1 : period === "week" ? 7 : 30,
+      taskMetrics: [],
+      qualityMetrics: [],
+      topTools: [],
+      toolFailureRate: 0,
+      source: "none"
+    };
+  }
+}
+async function fetchNpmStats(packageName = process.env.SQUADS_NPM_PACKAGE || "squads-cli") {
+  try {
+    const [dayRes, weekRes, monthRes] = await Promise.all([
+      fetchWithTimeout(`https://api.npmjs.org/downloads/point/last-day/${packageName}`, {}, 3e3),
+      fetchWithTimeout(`https://api.npmjs.org/downloads/point/last-week/${packageName}`, {}, 3e3),
+      fetchWithTimeout(`https://api.npmjs.org/downloads/point/last-month/${packageName}`, {}, 3e3)
+    ]);
+    if (!dayRes.ok || !weekRes.ok || !monthRes.ok) return null;
+    const [dayData, weekData, monthData] = await Promise.all([
+      dayRes.json(),
+      weekRes.json(),
+      monthRes.json()
+    ]);
+    const avgWeeklyFromMonth = monthData.downloads / 4;
+    const weekOverWeek = avgWeeklyFromMonth > 0 ? Math.round((weekData.downloads - avgWeeklyFromMonth) / avgWeeklyFromMonth * 100) : 0;
+    return {
+      package: packageName,
+      downloads: {
+        lastDay: dayData.downloads,
+        lastWeek: weekData.downloads,
+        lastMonth: monthData.downloads
+      },
+      weekOverWeek
+    };
+  } catch {
+    return null;
+  }
+}
+var OPUS_WEIGHT = 5;
+var SONNET_WEIGHT = 1;
+var HAIKU_WEIGHT = 0.25;
+var DEFAULT_WEEKLY_WEIGHTED_LIMIT = 4e6;
+var MAX5_SESSION_TOKEN_LIMIT = 2e6;
+async function fetchClaudeCodeCapacity() {
+  const { readFile } = await import("fs/promises");
+  const { homedir } = await import("os");
+  const { join } = await import("path");
+  try {
+    const cacheFile = join(homedir(), ".claude", "stats-cache.json");
+    const content = await readFile(cacheFile, "utf-8");
+    const data = JSON.parse(content);
+    const now = /* @__PURE__ */ new Date();
+    const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+    const weekStart = weekAgo.toISOString().split("T")[0];
+    let weeklyOpus = 0;
+    if (data.dailyModelTokens) {
+      for (const day of data.dailyModelTokens) {
+        if (day.date >= weekStart) {
+          for (const [model, tokens] of Object.entries(day.tokensByModel)) {
+            if (model.includes("opus")) {
+              weeklyOpus += tokens;
+            }
+          }
+        }
+      }
+    }
+    const weeklyLimit = parseInt(process.env.SQUADS_WEEKLY_LIMIT || "", 10) || DEFAULT_WEEKLY_WEIGHTED_LIMIT;
+    const today = now.toISOString().split("T")[0];
+    let sessionTokens = 0;
+    if (data.dailyModelTokens) {
+      const todayData = data.dailyModelTokens.find((d) => d.date === today);
+      if (todayData) {
+        sessionTokens = Object.values(todayData.tokensByModel).reduce((a, b) => a + b, 0);
+      }
+    }
+    const daysUntilSunday = (7 - now.getDay()) % 7 || 7;
+    const nextSunday = new Date(now);
+    nextSunday.setDate(now.getDate() + daysUntilSunday);
+    nextSunday.setHours(21, 59, 0, 0);
+    const sessionReset = new Date(now);
+    sessionReset.setHours(18, 59, 0, 0);
+    if (sessionReset < now) {
+      sessionReset.setDate(sessionReset.getDate() + 1);
+    }
+    let sonnetTokens = 0;
+    let haikuTokens = 0;
+    if (data.dailyModelTokens) {
+      for (const day of data.dailyModelTokens) {
+        if (day.date >= weekStart) {
+          for (const [model, tokens] of Object.entries(day.tokensByModel)) {
+            if (model.includes("sonnet")) {
+              sonnetTokens += tokens;
+            } else if (model.includes("haiku")) {
+              haikuTokens += tokens;
+            }
+          }
+        }
+      }
+    }
+    const weeklyWeighted = Math.round(
+      weeklyOpus * OPUS_WEIGHT + sonnetTokens * SONNET_WEIGHT + haikuTokens * HAIKU_WEIGHT
+    );
+    return {
+      weeklyTokensUsed: weeklyWeighted,
+      // Now weighted, not raw
+      weeklyTokensLimit: weeklyLimit,
+      weeklyCapacityPct: Math.round(weeklyWeighted / weeklyLimit * 100),
+      sessionTokensUsed: sessionTokens,
+      sessionTokensLimit: MAX5_SESSION_TOKEN_LIMIT,
+      sessionCapacityPct: Math.round(sessionTokens / MAX5_SESSION_TOKEN_LIMIT * 100),
+      opusTokensUsed: weeklyOpus,
+      sonnetTokensUsed: sonnetTokens,
+      haikuTokensUsed: haikuTokens,
+      weeklyResetDate: nextSunday.toLocaleDateString("en-US", { month: "short", day: "numeric" }),
+      sessionResetTime: sessionReset.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit" })
+    };
+  } catch {
+    return null;
+  }
+}
+function calculateROIMetrics(costs, goalsCompleted, commits, prsMerged, hoursTracked = 0) {
+  const totalCost = costs?.totalCost || 0;
+  const costPerGoal = goalsCompleted > 0 ? totalCost / goalsCompleted : 0;
+  const costPerCommit = commits > 0 ? totalCost / commits : 0;
+  const costPerPR = prsMerged > 0 ? totalCost / prsMerged : 0;
+  const GOAL_VALUE = parseFloat(process.env.SQUADS_GOAL_VALUE || "100");
+  const PR_VALUE = parseFloat(process.env.SQUADS_PR_VALUE || "200");
+  const COMMIT_VALUE = parseFloat(process.env.SQUADS_COMMIT_VALUE || "25");
+  const estimatedValue = goalsCompleted * GOAL_VALUE + prsMerged * PR_VALUE + commits * COMMIT_VALUE;
+  const roiMultiplier = totalCost > 0 ? estimatedValue / totalCost : 0;
+  const now = /* @__PURE__ */ new Date();
+  const hoursElapsed = hoursTracked > 0 ? hoursTracked : Math.max(now.getHours() + now.getMinutes() / 60, 1);
+  const costPerHour = totalCost / hoursElapsed;
+  return {
+    totalCostUsd: totalCost,
+    costPerGoal,
+    costPerCommit,
+    costPerPR,
+    estimatedValueUsd: estimatedValue,
+    roiMultiplier,
+    dailyProjectedCost: costPerHour * 24,
+    weeklyProjectedCost: costPerHour * 24 * 7,
+    monthlyProjectedCost: costPerHour * 24 * 30,
+    hoursTracked: hoursElapsed,
+    costPerHour
+  };
+}
+function calculateSquadCostProjections(bridgeStats, _history) {
+  if (!bridgeStats || bridgeStats.bySquad.length === 0) {
+    return [];
+  }
+  const now = /* @__PURE__ */ new Date();
+  const hoursElapsed = Math.max(now.getHours() + now.getMinutes() / 60, 1);
+  return bridgeStats.bySquad.map((squad) => {
+    const hourlyRate = squad.costUsd / hoursElapsed;
+    return {
+      squad: squad.squad,
+      currentDailyCost: squad.costUsd,
+      projectedDailyCost: hourlyRate * 24,
+      projectedWeeklyCost: hourlyRate * 24 * 7,
+      projectedMonthlyCost: hourlyRate * 24 * 30,
+      costTrend: "stable",
+      trendPct: 0
+    };
+  });
+}
+
+export {
+  detectPlan,
+  getPlanType,
+  isMaxPlan,
+  fetchCostSummary,
+  fetchBridgeStats,
+  fetchQuotaInfo,
+  fetchRateLimits,
+  fetchInsights,
+  fetchNpmStats,
+  fetchClaudeCodeCapacity,
+  calculateROIMetrics,
+  calculateSquadCostProjections
+};
+//# sourceMappingURL=chunk-WVOIY5GW.js.map