mergen-server 1.4.0

package/dist/intelligence/sql-ast.js

@@ -0,0 +1,31 @@
+import pkg from "node-sql-parser";
+const { Parser } = pkg;
+const parser = new Parser();
+const DIALECTS = ["mysql", "postgresql", "transactsql", "sqlite"];
+function extractSqlCandidate(text) {
+  const match = text.match(/\b(delete\s+from|update)\b[\s\S]*/i);
+  if (!match) return null;
+  return match[0].split(/;|\n|&&|\|\|/)[0].trim();
+}
+function sqlHasNoWhereClause(haystack) {
+  const candidate = extractSqlCandidate(haystack);
+  if (!candidate) return null;
+  for (const database of DIALECTS) {
+    try {
+      const ast = parser.astify(candidate, { database });
+      const statements = Array.isArray(ast) ? ast : [ast];
+      for (const stmt of statements) {
+        if (stmt?.type === "delete" || stmt?.type === "update") {
+          return stmt.where === null || stmt.where === void 0;
+        }
+      }
+      return null;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+export {
+  sqlHasNoWhereClause
+};

package/dist/intelligence/team.js

@@ -0,0 +1 @@
+export * from '../__stubs__/closed-source.js';

package/dist/intelligence/telemetry.js

@@ -0,0 +1,76 @@
+import fs from "fs/promises";
+import { randomUUID } from "crypto";
+import { DATA_DIR, TELEMETRY_FILE } from "../sensor/paths.js";
+import logger from "../sensor/logger.js";
+const THROTTLE_MS = 60 * 60 * 1e3;
+let _state = { enabled: false, installId: "" };
+let _lastSentAt = null;
+async function initTelemetry() {
+  let stored = {};
+  try {
+    const raw = await fs.readFile(TELEMETRY_FILE, "utf8");
+    stored = JSON.parse(raw);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      logger.warn({ err }, "telemetry: failed to read state file");
+    }
+  }
+  const installId = stored.installId ?? randomUUID();
+  const enabledFromEnv = process.env.MERGEN_TELEMETRY === "1";
+  const enabled = stored.enabled ?? enabledFromEnv;
+  _state = { enabled, installId };
+  try {
+    await fs.mkdir(DATA_DIR, { recursive: true });
+    await fs.writeFile(TELEMETRY_FILE, JSON.stringify(_state, null, 2));
+  } catch (err) {
+    logger.warn({ err }, "telemetry: failed to persist state");
+  }
+}
+function getTelemetryState() {
+  return { ..._state, lastSentAt: _lastSentAt };
+}
+async function setTelemetryEnabled(enabled) {
+  _state = { ..._state, enabled };
+  try {
+    await fs.mkdir(DATA_DIR, { recursive: true });
+    await fs.writeFile(TELEMETRY_FILE, JSON.stringify(_state, null, 2));
+  } catch (err) {
+    logger.warn({ err }, "telemetry: failed to persist enabled flag");
+  }
+}
+async function maybeSendTelemetry(payload) {
+  const url = process.env.MERGEN_TELEMETRY_URL;
+  if (!_state.enabled || !url) return false;
+  const now = Date.now();
+  if (_lastSentAt !== null && now - _lastSentAt < THROTTLE_MS) return false;
+  const body = {
+    installId: _state.installId,
+    serverVersion: payload.serverVersion,
+    planId: payload.planId,
+    toolCallCounts: payload.toolCallCounts,
+    bufferedEvents: payload.bufferedEvents,
+    ts: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      logger.warn({ status: res.status }, "telemetry: send failed");
+      return false;
+    }
+    _lastSentAt = now;
+    return true;
+  } catch (err) {
+    logger.warn({ err }, "telemetry: fetch error");
+    return false;
+  }
+}
+export {
+  getTelemetryState,
+  initTelemetry,
+  maybeSendTelemetry,
+  setTelemetryEnabled
+};

package/dist/intelligence/threshold-optimizer.js

@@ -0,0 +1,75 @@
+import { getRecords } from "./calibration.js";
+const BAND_MIDPOINT = {
+  LOW: 0.55,
+  MED: 0.72,
+  HIGH: 0.92
+};
+const MIN_SAMPLE_SIZE = 20;
+const CACHE_TTL_MS = 10 * 60 * 1e3;
+const DEFAULT_EXECUTION_THRESHOLD = 0.85;
+let _cachedThreshold = null;
+let _cacheTime = 0;
+function scoreOf(r) {
+  const extended = r;
+  return extended.numericScore ?? extended.confidenceScore ?? BAND_MIDPOINT[r.confidence] ?? 0.72;
+}
+function computeRocCurve() {
+  const verdicted = getRecords().filter((r) => r.verdict !== null);
+  if (verdicted.length < MIN_SAMPLE_SIZE) return [];
+  const samples = verdicted.map((r) => ({
+    score: scoreOf(r),
+    isCorrect: r.verdict === "correct" || r.verdict === "partial"
+  }));
+  const points = [];
+  for (let raw = 50; raw <= 95; raw += 5) {
+    const threshold = raw / 100;
+    let tp = 0, fp = 0, tn = 0, fn = 0;
+    for (const s of samples) {
+      const predicted = s.score >= threshold;
+      if (predicted && s.isCorrect) tp++;
+      if (predicted && !s.isCorrect) fp++;
+      if (!predicted && !s.isCorrect) tn++;
+      if (!predicted && s.isCorrect) fn++;
+    }
+    const tpr = tp + fn > 0 ? tp / (tp + fn) : 0;
+    const fpr = fp + tn > 0 ? fp / (fp + tn) : 0;
+    const precision = tp + fp > 0 ? tp / (tp + fp) : 0;
+    const recall = tpr;
+    const f1 = precision + recall > 0 ? 2 * precision * recall / (precision + recall) : 0;
+    points.push({
+      threshold,
+      tpr: Math.round(tpr * 1e3) / 1e3,
+      fpr: Math.round(fpr * 1e3) / 1e3,
+      precision: Math.round(precision * 1e3) / 1e3,
+      f1: Math.round(f1 * 1e3) / 1e3,
+      youdensJ: Math.round((tpr - fpr) * 1e3) / 1e3
+    });
+  }
+  return points;
+}
+function getExecutionThreshold() {
+  const now = Date.now();
+  if (_cachedThreshold !== null && now - _cacheTime < CACHE_TTL_MS) {
+    return _cachedThreshold;
+  }
+  const curve = computeRocCurve();
+  if (curve.length === 0) {
+    _cachedThreshold = DEFAULT_EXECUTION_THRESHOLD;
+    _cacheTime = now;
+    return DEFAULT_EXECUTION_THRESHOLD;
+  }
+  const best = curve.reduce((a, b) => b.youdensJ > a.youdensJ ? b : a);
+  const derived = Math.min(0.95, Math.max(0.7, best.threshold));
+  _cachedThreshold = derived;
+  _cacheTime = now;
+  return derived;
+}
+function invalidateThresholdCache() {
+  _cachedThreshold = null;
+}
+export {
+  DEFAULT_EXECUTION_THRESHOLD,
+  computeRocCurve,
+  getExecutionThreshold,
+  invalidateThresholdCache
+};

package/dist/intelligence/token-budget.js

@@ -0,0 +1,66 @@
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function truncateToTokenBudget(items, maxTokens, separator = "\n") {
+  if (!maxTokens || items.length === 0) {
+    const result2 = items.join(separator);
+    return {
+      result: result2,
+      truncated: false,
+      omitted: 0,
+      estimatedTokens: estimateTokens(result2)
+    };
+  }
+  let totalTokens = 0;
+  let included = 0;
+  for (let i = 0; i < items.length; i++) {
+    const itemTokens = estimateTokens(items[i]) + estimateTokens(separator);
+    if (totalTokens + itemTokens <= maxTokens) {
+      totalTokens += itemTokens;
+      included = i + 1;
+    } else {
+      break;
+    }
+  }
+  const omitted = items.length - included;
+  let result = items.slice(0, included).join(separator);
+  if (omitted > 0) {
+    const footer = `
+
+[...truncated, +${omitted} more items not shown due to token budget. Call again with higher max_tokens or add filters to reduce noise.]`;
+    result += footer;
+    totalTokens += estimateTokens(footer);
+  }
+  return {
+    result,
+    truncated: omitted > 0,
+    omitted,
+    estimatedTokens: totalTokens
+  };
+}
+function truncateText(text, maxTokens) {
+  const tokens = estimateTokens(text);
+  if (tokens <= maxTokens) {
+    return {
+      result: text,
+      truncated: false,
+      omitted: 0,
+      estimatedTokens: tokens
+    };
+  }
+  const maxChars = maxTokens * 4;
+  const truncated = text.slice(0, maxChars);
+  const omittedChars = text.length - maxChars;
+  const footer = `
+[...truncated, +${omittedChars} more characters]`;
+  return {
+    result: truncated + footer,
+    truncated: true,
+    omitted: 1,
+    estimatedTokens: estimateTokens(truncated + footer)
+  };
+}
+export {
+  truncateText,
+  truncateToTokenBudget
+};