ctxloom-pro 1.3.0 → 1.4.0

package/dist/budgetStats-TURA232F.js

@@ -0,0 +1,116 @@
+// packages/core/src/utils/stats.ts
+function percentile(values, p) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = Math.floor((sorted.length - 1) * p);
+  return sorted[idx];
+}
+
+// packages/core/src/budget/budgetStats.ts
+function summarize(events, windowStart, windowEnd) {
+  const byTool = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const existing = byTool.get(e.tool);
+    if (existing) existing.push(e);
+    else byTool.set(e.tool, [e]);
+  }
+  const fallbackTable = [];
+  const distributionTable = [];
+  for (const [tool, bucket] of byTool) {
+    const fallbackUsed = bucket.filter((e) => e.event === "mcp.fallback.used");
+    if (fallbackUsed.length > 0) {
+      let skeleton = 0, truncate = 0, error = 0;
+      for (const e of fallbackUsed) {
+        const mode = typeof e.mode === "string" ? e.mode : "";
+        if (mode === "skeleton" || mode === "skeleton+truncate") skeleton++;
+        else if (mode === "truncate" || mode === "truncate-fallback") truncate++;
+        else if (mode === "error") error++;
+      }
+      const total = skeleton + truncate + error;
+      if (total > 0) {
+        fallbackTable.push({
+          tool,
+          breaches: fallbackUsed.length,
+          skeletonPct: Math.round(skeleton / total * 100),
+          truncatePct: Math.round(truncate / total * 100),
+          errorPct: Math.round(error / total * 100)
+        });
+      }
+    }
+    const tokens = bucket.filter((e) => e.event === "mcp.budget.exceeded").map((e) => typeof e.original_tokens === "number" ? e.original_tokens : null).filter((n) => n !== null);
+    if (tokens.length > 0) {
+      distributionTable.push({
+        tool,
+        n: tokens.length,
+        min: Math.min(...tokens),
+        p50: percentile(tokens, 0.5),
+        p75: percentile(tokens, 0.75),
+        p95: percentile(tokens, 0.95),
+        max: Math.max(...tokens)
+      });
+    }
+  }
+  fallbackTable.sort((a, b) => a.tool.localeCompare(b.tool));
+  distributionTable.sort((a, b) => a.tool.localeCompare(b.tool));
+  return {
+    windowStart: windowStart.toISOString(),
+    windowEnd: windowEnd.toISOString(),
+    totalEvents: events.length,
+    fallbackTable,
+    distributionTable
+  };
+}
+function renderSummary(s) {
+  const lines = [];
+  const startDate = s.windowStart.slice(0, 10);
+  const endDate = s.windowEnd.slice(0, 10);
+  lines.push(`Budget event summary (${startDate} \u2192 ${endDate}, ${s.totalEvents} events)`);
+  lines.push("");
+  if (s.totalEvents === 0) {
+    lines.push("No events in window. Either:");
+    lines.push("  - No budget breaches occurred (everything fit under budgets)");
+    lines.push(`  - CTXLOOM_TELEMETRY_LEVEL is not set to "full" in the MCP server's env`);
+    lines.push("  - No tool calls have opted into the budget surface yet");
+    return lines.join("\n");
+  }
+  lines.push("Fallback distribution per tool");
+  lines.push("");
+  if (s.fallbackTable.length === 0) {
+    lines.push("  (no fallback events recorded in window)");
+  } else {
+    lines.push("| Tool                       | Breaches | Skeleton % | Truncate % | Error % |");
+    lines.push("|----------------------------|---------:|-----------:|-----------:|--------:|");
+    for (const r of s.fallbackTable) {
+      lines.push(
+        `| ${r.tool.padEnd(26)} | ${String(r.breaches).padStart(8)} | ${String(r.skeletonPct).padStart(9)}% | ${String(r.truncatePct).padStart(9)}% | ${String(r.errorPct).padStart(6)}% |`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("Original-token distribution per tool (over-budget calls only)");
+  lines.push("");
+  if (s.distributionTable.length === 0) {
+    lines.push("  (no budget-breach events recorded in window)");
+  } else {
+    lines.push("| Tool                       |   n |    min |    p50 |    p75 |    p95 |    max |");
+    lines.push("|----------------------------|----:|-------:|-------:|-------:|-------:|-------:|");
+    for (const r of s.distributionTable) {
+      lines.push(
+        `| ${r.tool.padEnd(26)} | ${String(r.n).padStart(3)} | ${fmt(r.min)} | ${fmt(r.p50)} | ${fmt(r.p75)} | ${fmt(r.p95)} | ${fmt(r.max)} |`
+      );
+    }
+    lines.push("");
+    lines.push("The **p75** column is the input for per-tool default budget tuning");
+    lines.push("(packages/core/src/tools/*.ts \u2192 DEFAULT_MAX_RESPONSE_TOKENS).");
+  }
+  return lines.join("\n");
+}
+function fmt(n) {
+  return n === null ? "     \u2014" : String(n).padStart(6);
+}
+export {
+  percentile,
+  renderSummary,
+  summarize
+};
+//# sourceMappingURL=budgetStats-TURA232F.js.map

package/dist/chunk-5I6CJITG.js

@@ -0,0 +1,99 @@
+import {
+  logger
+} from "./chunk-TYDMSHV7.js";
+
+// packages/core/src/budget/eventCollector.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var DEFAULT_TELEMETRY_DIR = path.join(os.homedir(), ".ctxloom", "telemetry");
+function telemetryDir() {
+  const raw = process.env.CTXLOOM_TELEMETRY_DIR ?? DEFAULT_TELEMETRY_DIR;
+  if (raw.includes("..") || !path.isAbsolute(raw)) {
+    if (!telemetryDirWarned) {
+      telemetryDirWarned = true;
+      logger.warn('CTXLOOM_TELEMETRY_DIR rejected \u2014 must be an absolute path with no ".." segments; using default', {
+        rejected: raw,
+        fallback: DEFAULT_TELEMETRY_DIR
+      });
+    }
+    return DEFAULT_TELEMETRY_DIR;
+  }
+  return path.resolve(raw);
+}
+var telemetryDirWarned = false;
+function filenameForDate(date) {
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(date.getUTCDate()).padStart(2, "0");
+  return `budget-events-${y}-${m}-${d}.jsonl`;
+}
+function appendEvent(event, now = /* @__PURE__ */ new Date()) {
+  try {
+    const dir = telemetryDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, filenameForDate(now));
+    const persisted = { ts: now.toISOString(), ...event };
+    fs.appendFileSync(file, JSON.stringify(persisted) + "\n", "utf-8");
+  } catch (err) {
+    if (!appendFailureWarned) {
+      appendFailureWarned = true;
+      logger.warn("telemetry sink append failed (further failures suppressed)", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+}
+var appendFailureWarned = false;
+function __resetTelemetryWarnFlagsForTests() {
+  telemetryDirWarned = false;
+  appendFailureWarned = false;
+}
+function readEvents(opts = {}) {
+  const until = opts.until ?? /* @__PURE__ */ new Date();
+  const since = opts.since ?? new Date(until.getTime() - 14 * 24 * 60 * 60 * 1e3);
+  const dir = telemetryDir();
+  if (!fs.existsSync(dir)) return [];
+  const out = [];
+  for (let cursor = new Date(Date.UTC(since.getUTCFullYear(), since.getUTCMonth(), since.getUTCDate())); cursor.getTime() <= until.getTime(); cursor = new Date(cursor.getTime() + 24 * 60 * 60 * 1e3)) {
+    const file = path.join(dir, filenameForDate(cursor));
+    if (!fs.existsSync(file)) continue;
+    const text = fs.readFileSync(file, "utf-8");
+    for (const line of text.split("\n")) {
+      if (line.trim() === "") continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!isPersistedEvent(parsed)) continue;
+      const eventTs = new Date(parsed.ts).getTime();
+      if (!Number.isFinite(eventTs)) continue;
+      if (eventTs < since.getTime() || eventTs > until.getTime()) continue;
+      if (opts.tool && parsed.tool !== opts.tool) continue;
+      out.push(parsed);
+    }
+  }
+  return out;
+}
+function isPersistedEvent(v) {
+  if (!v || typeof v !== "object") return false;
+  const o = v;
+  return typeof o.ts === "string" && typeof o.event === "string" && typeof o.tool === "string";
+}
+var diskSink = {
+  append(event) {
+    appendEvent(event);
+  }
+};
+
+export {
+  telemetryDir,
+  filenameForDate,
+  appendEvent,
+  __resetTelemetryWarnFlagsForTests,
+  readEvents,
+  diskSink
+};
+//# sourceMappingURL=chunk-5I6CJITG.js.map