mergen-server 1.4.0

package/dist/datadog/blame-attribution.js

@@ -0,0 +1,228 @@
+import { execSync } from "child_process";
+import path from "path";
+import logger from "../sensor/logger.js";
+const HIGH_CONFIDENCE = 0.8;
+const LOW_CONFIDENCE = 0.6;
+const ALL_SIGNALS_BONUS = 0.05;
+const TIMING_ONLY_CAP = 0.55;
+function computeBlameAttribution(opts) {
+  const { implicatedFile, deployedSha, firedAt, candidates, prUrl } = opts;
+  const priorDeploys = candidates.filter((d) => d.timestamp <= firedAt && d.status === "success").sort((a, b) => b.timestamp - a.timestamp);
+  if (priorDeploys.length === 0) {
+    return null;
+  }
+  const scored = priorDeploys.slice(0, 5).map((deploy) => ({
+    deploy,
+    attribution: _scoreCandidate({ deploy, implicatedFile, deployedSha, firedAt })
+  }));
+  scored.sort((a, b) => b.attribution.confidence - a.attribution.confidence);
+  const best = scored[0];
+  if (!best) return null;
+  return {
+    ...best.attribution,
+    topCandidate: {
+      sha: best.deploy.sha,
+      deployedAt: best.deploy.timestamp,
+      environment: best.deploy.environment,
+      prUrl: prUrl ?? best.deploy.url ?? null
+    }
+  };
+}
+function _scoreCandidate(opts) {
+  const { deploy, implicatedFile, deployedSha, firedAt } = opts;
+  const timing = _timingSignal(deploy.timestamp, firedAt);
+  const shaMatch = _shaMatchSignal(deployedSha, deploy.sha);
+  const changedFiles = _getChangedFiles(deploy.sha);
+  const fileOverlap = _fileOverlapSignal(implicatedFile, changedFiles);
+  const timingFired = timing.available && timing.score > 0;
+  const shaFired = shaMatch.available && shaMatch.score > 0;
+  const overlapFired = fileOverlap.available && fileOverlap.score > 0;
+  const signalsFired = [timingFired, shaFired, overlapFired].filter(Boolean).length;
+  let confidence = timing.contribution + shaMatch.contribution + fileOverlap.contribution;
+  if (signalsFired === 3) confidence = Math.min(1, confidence + ALL_SIGNALS_BONUS);
+  if (timingFired && !shaFired && !overlapFired) confidence = Math.min(confidence, TIMING_ONLY_CAP);
+  const confidenceLabel = confidence >= HIGH_CONFIDENCE ? "HIGH" : confidence >= LOW_CONFIDENCE ? "MEDIUM" : "LOW";
+  const explanation = _buildExplanation({ deploy, timing, shaMatch, fileOverlap, confidence, signalsFired, firedAt });
+  return {
+    confidence: Math.min(1, confidence),
+    confidenceLabel,
+    signals: { timing, shaMatch, fileOverlap },
+    explanation,
+    lowConfidence: confidence < LOW_CONFIDENCE,
+    changedFiles
+  };
+}
+function _timingSignal(deployedAt, firedAt) {
+  const WEIGHT = 0.4;
+  const deltaMs = firedAt - deployedAt;
+  const deltaSec = deltaMs / 1e3;
+  const deltaMin = deltaMs / 6e4;
+  let score;
+  let detail;
+  if (deltaMin < 2) {
+    score = 1;
+    detail = `deploy merged ${Math.round(deltaSec)}s before first error \u2014 extremely tight window`;
+  } else if (deltaMin < 5) {
+    score = 0.8;
+    detail = `deploy merged ${Math.round(deltaMin)}m before first error \u2014 very tight window`;
+  } else if (deltaMin < 15) {
+    score = 0.55;
+    detail = `deploy merged ${Math.round(deltaMin)}m before first error \u2014 plausible window`;
+  } else if (deltaMin < 30) {
+    score = 0.3;
+    detail = `deploy merged ${Math.round(deltaMin)}m before first error \u2014 possible but loose`;
+  } else {
+    score = 0.05;
+    detail = `deploy merged ${Math.round(deltaMin)}m before first error \u2014 weak temporal link`;
+  }
+  return { score, weight: WEIGHT, contribution: score * WEIGHT, detail, available: true };
+}
+function _shaMatchSignal(incidentSha, deploySha) {
+  const WEIGHT = 0.3;
+  if (!incidentSha) {
+    return {
+      score: 0,
+      weight: WEIGHT,
+      contribution: 0,
+      detail: "no buildSha in incident \u2014 browser events lack git SHA or Datadog span missing git.commit.sha",
+      available: false
+    };
+  }
+  const matches = deploySha === incidentSha || deploySha.startsWith(incidentSha) || incidentSha.startsWith(deploySha);
+  if (matches) {
+    return {
+      score: 1,
+      weight: WEIGHT,
+      contribution: WEIGHT,
+      detail: `browser buildSha \`${incidentSha.slice(0, 8)}\` matches deploy SHA \u2014 confirmed same artifact`,
+      available: true
+    };
+  }
+  return {
+    score: 0,
+    weight: WEIGHT,
+    contribution: 0,
+    detail: `browser buildSha \`${incidentSha.slice(0, 8)}\` does not match deploy SHA \`${deploySha.slice(0, 8)}\` \u2014 different artifact`,
+    available: true
+  };
+}
+function _fileOverlapSignal(implicatedFile, changedFiles) {
+  const WEIGHT = 0.3;
+  if (!implicatedFile) {
+    return {
+      score: 0,
+      weight: WEIGHT,
+      contribution: 0,
+      detail: "no implicated file from stack trace \u2014 sourcemap resolution unavailable",
+      available: false
+    };
+  }
+  if (changedFiles.length === 0) {
+    return {
+      score: 0,
+      weight: WEIGHT,
+      contribution: 0,
+      detail: "git diff unavailable \u2014 cannot check file overlap (no git repo or SHA not found)",
+      available: false
+    };
+  }
+  const basename = path.basename(implicatedFile);
+  const implicatedDir = path.dirname(implicatedFile).split("/").filter(Boolean).pop() ?? "";
+  for (const f of changedFiles) {
+    if (f === implicatedFile || f.endsWith("/" + implicatedFile) || implicatedFile.endsWith("/" + f)) {
+      return {
+        score: 1,
+        weight: WEIGHT,
+        contribution: WEIGHT,
+        detail: `\`${f}\` in deploy diff \u2014 exact match with implicated file \`${implicatedFile}\``,
+        available: true
+      };
+    }
+  }
+  for (const f of changedFiles) {
+    if (path.basename(f) === basename) {
+      return {
+        score: 0.75,
+        weight: WEIGHT,
+        contribution: 0.75 * WEIGHT,
+        detail: `\`${f}\` in deploy diff \u2014 same filename as implicated \`${basename}\` (path differs, possibly Docker mount)`,
+        available: true
+      };
+    }
+  }
+  for (const f of changedFiles) {
+    if (implicatedDir && path.dirname(f).split("/").filter(Boolean).pop() === implicatedDir) {
+      return {
+        score: 0.35,
+        weight: WEIGHT,
+        contribution: 0.35 * WEIGHT,
+        detail: `deploy modified files in \`${implicatedDir}/\` \u2014 same directory as implicated file, weak overlap`,
+        available: true
+      };
+    }
+  }
+  return {
+    score: 0,
+    weight: WEIGHT,
+    contribution: 0,
+    detail: `implicated file \`${basename}\` not in deploy diff \u2014 different area of codebase changed`,
+    available: true
+  };
+}
+function _getChangedFiles(sha) {
+  try {
+    const output = execSync(`git diff --name-only ${sha}^..${sha}`, {
+      timeout: 5e3,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.trim().split("\n").filter(Boolean);
+  } catch {
+    try {
+      const output = execSync(`git show --name-only --format="" ${sha}`, {
+        timeout: 5e3,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return output.trim().split("\n").filter(Boolean);
+    } catch {
+      logger.debug({ sha }, "git diff unavailable for blame attribution");
+      return [];
+    }
+  }
+}
+function _buildExplanation(opts) {
+  const { deploy, timing, shaMatch, fileOverlap, confidence, signalsFired } = opts;
+  const sha8 = deploy.sha.slice(0, 8);
+  const pct = Math.round(confidence * 100);
+  const available = [timing, shaMatch, fileOverlap].filter((s) => s.available);
+  const strong = available.filter((s) => s.score >= 0.75);
+  let core = `Deploy \`${sha8}\` (${deploy.environment}) \u2014 ${pct}% confidence, ${signalsFired}/3 signals fired.`;
+  if (signalsFired === 3) {
+    core += " All three signals corroborate: " + available.map((s) => s.detail).join("; ") + ".";
+  } else if (signalsFired === 1 && timing.score > 0 && !shaMatch.score && !fileOverlap.score) {
+    core += " Only timing fired \u2014 high-traffic services produce errors near every deploy; treat as weak hypothesis. " + timing.detail + ".";
+  } else if (strong.length > 0) {
+    core += " Strong signals: " + strong.map((s) => s.detail).join("; ") + ".";
+    const weak = available.filter((s) => s.score < 0.75 && s.score > 0);
+    if (weak.length) core += " Weaker signals: " + weak.map((s) => s.detail).join("; ") + ".";
+  } else {
+    core += " Signals: " + available.map((s) => s.detail).join("; ") + ".";
+  }
+  const unavailable = [timing, shaMatch, fileOverlap].filter((s) => !s.available);
+  if (unavailable.length > 0) {
+    core += ` Missing data for: ${unavailable.map((s, i) => ["timing", "shaMatch", "fileOverlap"][i]).join(", ")}.`;
+  }
+  if (confidence < LOW_CONFIDENCE) {
+    core += " Confidence below threshold \u2014 recommend manual investigation before acting.";
+  }
+  return core;
+}
+function validateAttribution(attributedSha, fixSha) {
+  if (!attributedSha || !fixSha) return null;
+  return attributedSha.startsWith(fixSha) || fixSha.startsWith(attributedSha);
+}
+export {
+  computeBlameAttribution,
+  validateAttribution
+};

package/dist/datadog/client.js

@@ -0,0 +1,159 @@
+import { readFileSync, existsSync } from "fs";
+import path from "path";
+import { DATA_DIR } from "../sensor/paths.js";
+import { startClientSpan } from "./otel-trace.js";
+function loadConfig() {
+  if (process.env.DD_API_KEY && process.env.DD_APP_KEY) {
+    return {
+      apiKey: process.env.DD_API_KEY,
+      appKey: process.env.DD_APP_KEY,
+      site: process.env.DATADOG_SITE ?? process.env.DD_SITE ?? "datadoghq.com"
+    };
+  }
+  const configPath = path.join(DATA_DIR, "config.json");
+  if (existsSync(configPath)) {
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf8"));
+      if (raw.datadog?.apiKey && raw.datadog?.appKey) {
+        return {
+          apiKey: raw.datadog.apiKey,
+          appKey: raw.datadog.appKey,
+          site: raw.datadog.site ?? "datadoghq.com"
+        };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function ddPost(config, endpoint, body) {
+  const url = `https://api.${config.site}${endpoint}`;
+  const span = startClientSpan();
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "DD-API-KEY": config.apiKey,
+      "DD-APPLICATION-KEY": config.appKey,
+      "traceparent": span.traceparent
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Datadog API ${res.status}: ${text.slice(0, 200)}`);
+  }
+  return res.json();
+}
+async function fetchSpans(opts) {
+  const config = loadConfig();
+  if (!config) throw new Error("Datadog not configured. Run: mergen-server init");
+  const queryParts = [];
+  if (opts.service) queryParts.push(`service:${opts.service}`);
+  if (opts.errorsOnly) queryParts.push("status:error");
+  const raw = await ddPost(config, "/api/v2/spans", {
+    filter: {
+      from: opts.from.toISOString(),
+      to: opts.to.toISOString(),
+      query: queryParts.join(" ") || "*"
+    },
+    page: { limit: opts.limit ?? 100 },
+    sort: "-timestamp"
+  });
+  return (raw.data ?? []).map((d) => ({
+    id: d.id,
+    traceId: d.attributes.trace_id,
+    service: d.attributes.service,
+    resourceName: d.attributes.resource_name,
+    durationNs: d.attributes.duration,
+    status: d.attributes.status,
+    startNs: d.attributes.start,
+    tags: d.attributes.tags ?? {}
+  }));
+}
+async function fetchLogsByTraceId(opts) {
+  const config = loadConfig();
+  if (!config) throw new Error("Datadog not configured. Run: mergen-server init");
+  const queryParts = [`trace_id:${opts.traceId}`];
+  if (opts.errorsOnly) queryParts.push("status:error");
+  const raw = await ddPost(config, "/api/v2/logs/events/search", {
+    filter: {
+      from: opts.from.toISOString(),
+      to: opts.to.toISOString(),
+      query: queryParts.join(" ")
+    },
+    page: { limit: 50 }
+  });
+  return (raw.data ?? []).map((d) => ({
+    id: d.id,
+    timestamp: d.attributes.timestamp,
+    message: d.attributes.message,
+    status: d.attributes.status,
+    service: d.attributes.service,
+    tags: Object.fromEntries(
+      (d.attributes.tags ?? []).map((t) => {
+        const idx = t.indexOf(":");
+        return idx === -1 ? [t, ""] : [t.slice(0, idx), t.slice(idx + 1)];
+      })
+    ),
+    attributes: d.attributes.attributes ?? {}
+  }));
+}
+async function fetchLatestErrorTrace(service, windowMinutes = 10) {
+  const to = /* @__PURE__ */ new Date();
+  const from = new Date(to.getTime() - windowMinutes * 60 * 1e3);
+  const errorSpans = await fetchSpans({ service, from, to, errorsOnly: true, limit: 50 });
+  if (errorSpans.length === 0) return null;
+  const byTrace = /* @__PURE__ */ new Map();
+  for (const s of errorSpans) {
+    byTrace.set(s.traceId, (byTrace.get(s.traceId) ?? 0) + 1);
+  }
+  const bestTraceId = [...byTrace.entries()].sort((a, b) => b[1] - a[1])[0][0];
+  const allSpans = await fetchSpans({ service, from, to, limit: 200 });
+  const traceSpans = allSpans.filter((s) => s.traceId === bestTraceId);
+  return { traceId: bestTraceId, spans: traceSpans };
+}
+async function fetchErrorCountSince(service, windowMinutes) {
+  const config = loadConfig();
+  if (!config) return null;
+  const to = /* @__PURE__ */ new Date();
+  const from = new Date(to.getTime() - windowMinutes * 6e4);
+  try {
+    const raw = await ddPost(config, "/api/v2/spans", {
+      filter: {
+        from: from.toISOString(),
+        to: to.toISOString(),
+        query: `service:${service} status:error`
+      },
+      page: { limit: 1 },
+      sort: "-timestamp"
+    });
+    return raw.data?.length ?? 0;
+  } catch {
+    return null;
+  }
+}
+async function testConnection() {
+  const config = loadConfig();
+  if (!config) throw new Error("No credentials found");
+  const res = await fetch(`https://api.${config.site}/api/v1/validate`, {
+    headers: { "DD-API-KEY": config.apiKey, "DD-APPLICATION-KEY": config.appKey },
+    signal: AbortSignal.timeout(8e3)
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Auth failed (${res.status}): ${body.slice(0, 100)}`);
+  }
+}
+function isConfigured() {
+  return loadConfig() !== null;
+}
+export {
+  fetchErrorCountSince,
+  fetchLatestErrorTrace,
+  fetchLogsByTraceId,
+  fetchSpans,
+  isConfigured,
+  testConnection
+};

package/dist/datadog/compactor.js

@@ -0,0 +1,169 @@
+import { fetchLogsByTraceId } from "./client.js";
+import { matchLines } from "./line-matcher.js";
+function pruneTrace(spans) {
+  if (spans.length === 0) return [];
+  const maxDuration = Math.max(...spans.map((s) => s.durationNs));
+  const threshold = maxDuration * 0.05;
+  return spans.filter((s) => s.status === "error" || s.durationNs >= threshold);
+}
+const KEEP_PREFIXES = [
+  "error.",
+  "exception.",
+  "db.",
+  "http.status_code",
+  "http.url",
+  "http.method",
+  "http.route",
+  "git.commit",
+  "net.peer.name"
+];
+const STRIP_PREFIXES = [
+  "container_",
+  "k8s.",
+  "os.",
+  "process.runtime",
+  "net.transport",
+  "network.",
+  "peer.",
+  "otel.",
+  "http.scheme",
+  "http.flavor",
+  "messaging."
+];
+function stripAttributes(tags) {
+  const out = {};
+  for (const [k, v] of Object.entries(tags)) {
+    if (STRIP_PREFIXES.some((p) => k.startsWith(p))) continue;
+    if (KEEP_PREFIXES.some((p) => k.startsWith(p))) out[k] = v;
+  }
+  return out;
+}
+async function inlineLogs(spans, from, to) {
+  const traceIds = [...new Set(spans.map((s) => s.traceId))];
+  const logsByTrace = /* @__PURE__ */ new Map();
+  await Promise.all(
+    traceIds.map(async (traceId) => {
+      try {
+        const logs = await fetchLogsByTraceId({ traceId, from, to, errorsOnly: true });
+        if (logs.length > 0) logsByTrace.set(traceId, logs);
+      } catch {
+      }
+    })
+  );
+  return spans.map((s) => ({ ...s, inlinedLogs: logsByTrace.get(s.traceId) }));
+}
+function parseTopFrame(stack) {
+  const goMatch = stack.match(/\t([^:\s]+\.go):(\d+)/);
+  if (goMatch) return { file: goMatch[1], line: parseInt(goMatch[2], 10) };
+  const nodeMatch = stack.match(/at\s+\S+\s+\(([^:)]+):(\d+):\d+\)/);
+  if (nodeMatch) return { file: nodeMatch[1], line: parseInt(nodeMatch[2], 10) };
+  const pyMatch = stack.match(/File "([^"]+)", line (\d+)/);
+  if (pyMatch) return { file: pyMatch[1], line: parseInt(pyMatch[2], 10) };
+  return null;
+}
+async function serializeToFact(spans, traceId) {
+  const errorSpans = spans.filter((s) => s.status === "error");
+  const root = errorSpans[0] ?? spans[0];
+  if (!root) throw new Error("No spans to serialize");
+  const service = root.service;
+  const endpoint = root.resourceName;
+  const errorMsg = root.tags["error.message"] ?? root.tags["error.msg"] ?? "Unknown error";
+  const errorType = root.tags["error.type"] ?? root.tags["exception.type"] ?? "";
+  const errorStack = root.tags["error.stack"] ?? root.tags["exception.stacktrace"] ?? "";
+  const deployedSha = root.tags["git.commit.sha"] ?? root.tags["git.commit"];
+  const durationMs = Math.round(root.durationNs / 1e6);
+  let failingFile;
+  let failingLine;
+  let codeContext;
+  const frame = errorStack ? parseTopFrame(errorStack) : null;
+  if (frame) {
+    failingFile = frame.file;
+    failingLine = frame.line;
+    try {
+      codeContext = await matchLines(failingFile, failingLine, deployedSha);
+    } catch {
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const logLines = [];
+  for (const s of spans) {
+    for (const l of s.inlinedLogs ?? []) {
+      const key = l.message.slice(0, 80);
+      if (!seen.has(key)) {
+        seen.add(key);
+        logLines.push(l.message.slice(0, 200));
+      }
+      if (logLines.length >= 5) break;
+    }
+  }
+  const lines = [
+    "## MERGEN RUNTIME FACT",
+    "",
+    `**Failure Endpoint:** \`${endpoint}\` (Service: \`${service}\`)`,
+    `**Trace ID:** \`${traceId}\``,
+    `**Duration:** ${durationMs}ms`,
+    "",
+    errorType ? `**Exception:** \`${errorType}: ${errorMsg}\`` : `**Error:** ${errorMsg}`
+  ];
+  const dbStatement = root.tags["db.statement"];
+  if (dbStatement) {
+    lines.push("", "**Failing Query:**", "```sql", dbStatement.slice(0, 500), "```");
+  }
+  const httpStatus = root.tags["http.status_code"];
+  if (httpStatus) lines.push("", `**HTTP Status:** ${httpStatus}`);
+  if (errorStack) {
+    const topFrames = errorStack.split("\n").slice(0, 8).join("\n");
+    lines.push("", "**Stack Trace (top frames):**", "```", topFrames, "```");
+  }
+  if (codeContext && failingFile && failingLine) {
+    lines.push(
+      "",
+      `**Local Code Context** (\`${failingFile}:${failingLine}\`):`,
+      "```",
+      codeContext,
+      "```"
+    );
+  } else if (failingFile && failingLine) {
+    lines.push("", `**Failing Location:** \`${failingFile}:${failingLine}\` *(local workspace not matched)*`);
+  }
+  if (logLines.length > 0) {
+    lines.push("", "**Correlated Error Logs:**");
+    for (const l of logLines) lines.push(`- ${l}`);
+  }
+  if (deployedSha) {
+    lines.push(
+      "",
+      `**Deployed Commit:** \`${deployedSha.slice(0, 7)}\``,
+      `*Run \`git show ${deployedSha.slice(0, 7)}\` to see what changed.*`
+    );
+  }
+  const rawKb = Math.round(JSON.stringify(spans).length / 1024);
+  const factKb = Math.max(1, Math.round(lines.join("\n").length / 1024));
+  lines.push(
+    "",
+    "---",
+    `*Compacted ${rawKb}KB raw trace (${spans.length} spans) \u2192 ${factKb}KB Runtime Fact*`
+  );
+  return {
+    markdown: lines.join("\n"),
+    service,
+    traceId,
+    endpoint,
+    errorMessage: errorMsg,
+    failingFile,
+    failingLine,
+    deployedSha,
+    rawSpanCount: spans.length,
+    compactedSpanCount: errorSpans.length
+  };
+}
+async function compact(input) {
+  const pruned = pruneTrace(input.spans);
+  const stripped = pruned.map((s) => ({ ...s, tags: stripAttributes(s.tags) }));
+  const withLogs = await inlineLogs(stripped, input.timeWindow.from, input.timeWindow.to);
+  const fact = await serializeToFact(withLogs, input.traceId);
+  return { fact };
+}
+export {
+  compact
+};

package/dist/datadog/fingerprinter.js

@@ -0,0 +1,34 @@
+import crypto from "crypto";
+function normalizeEndpoint(raw) {
+  return raw.toLowerCase().replace(/\/\d+/g, "/{id}").replace(/\/[0-9a-f]{8}-[0-9a-f-]{23,35}/g, "/{uuid}").replace(/[^a-z0-9:/_{}]/g, "");
+}
+function errorClass(msg) {
+  return msg.trim().split(/[\s:,.(]/)[0].toLowerCase().slice(0, 24);
+}
+function extractTable(stmt) {
+  const m = stmt.match(/(?:FROM|INTO|UPDATE|JOIN)\s+["'`]?(\w+)["'`]?/i);
+  return m ? m[1].toLowerCase() : "";
+}
+function computeFingerprint(input) {
+  const et = (input.errorType ?? "").toLowerCase().replace(/[^a-z0-9.]/g, "");
+  const svc = input.service.toLowerCase().replace(/[^a-z0-9-]/g, "");
+  const ep = normalizeEndpoint(input.endpoint);
+  const tbl = (input.dbTable ?? "").toLowerCase().replace(/[^a-z0-9_]/g, "");
+  const ec = input.errorMessage ? errorClass(input.errorMessage) : "";
+  const key = [et, svc, ep, tbl, ec].join("|");
+  return crypto.createHash("sha256").update(key).digest("hex").slice(0, 16);
+}
+function fingerprintFromFact(fact) {
+  const dbTable = extractTable(fact.errorMessage);
+  return computeFingerprint({
+    errorType: fact.errorMessage.split(":")[0],
+    service: fact.service,
+    endpoint: fact.endpoint,
+    dbTable,
+    errorMessage: fact.errorMessage
+  });
+}
+export {
+  computeFingerprint,
+  fingerprintFromFact
+};

package/dist/datadog/incident-state.js

@@ -0,0 +1,21 @@
+const INCIDENT_TTL_MS = 2 * 60 * 60 * 1e3;
+let activeIncident = null;
+function setActiveIncident(incident) {
+  activeIncident = incident;
+}
+function getActiveIncident() {
+  if (!activeIncident) return null;
+  if (Date.now() - activeIncident.firedAt > INCIDENT_TTL_MS) {
+    activeIncident = null;
+    return null;
+  }
+  return activeIncident;
+}
+function clearActiveIncident() {
+  activeIncident = null;
+}
+export {
+  clearActiveIncident,
+  getActiveIncident,
+  setActiveIncident
+};

package/dist/datadog/line-matcher.js

@@ -0,0 +1,56 @@
+import { readFileSync, existsSync } from "fs";
+import { execSync } from "child_process";
+import path from "path";
+const CONTEXT_LINES = 15;
+function findLocalFile(filePath, cwd = process.cwd()) {
+  if (path.isAbsolute(filePath) && existsSync(filePath)) return filePath;
+  const rel = path.resolve(cwd, filePath);
+  if (existsSync(rel)) return rel;
+  const parts = filePath.split("/");
+  for (let i = 1; i < parts.length; i++) {
+    const candidate = path.resolve(cwd, parts.slice(i).join("/"));
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function localHeadSha() {
+  try {
+    return execSync("git rev-parse HEAD", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+async function matchLines(filePath, lineNumber, deployedSha) {
+  const localFile = findLocalFile(filePath);
+  if (!localFile) {
+    return `[file not found in local workspace: ${filePath}]`;
+  }
+  let shaWarning = "";
+  if (deployedSha) {
+    const localSha = localHeadSha();
+    if (localSha && !localSha.startsWith(deployedSha.slice(0, 7)) && !deployedSha.startsWith(localSha.slice(0, 7))) {
+      shaWarning = `
+\u26A0 SHA mismatch: deployed=${deployedSha.slice(0, 7)}, local=${localSha.slice(0, 7)} \u2014 code below may differ from what's running in production`;
+    }
+  }
+  try {
+    const content = readFileSync(localFile, "utf8");
+    const allLines = content.split("\n");
+    const start = Math.max(0, lineNumber - CONTEXT_LINES - 1);
+    const end = Math.min(allLines.length, lineNumber + CONTEXT_LINES);
+    const excerpt = allLines.slice(start, end).map((line, i) => {
+      const ln = start + i + 1;
+      const marker = ln === lineNumber ? ">>>" : "   ";
+      return `${marker} ${String(ln).padStart(4)}: ${line}`;
+    }).join("\n");
+    return excerpt + shaWarning;
+  } catch {
+    return `[could not read ${localFile}]${shaWarning}`;
+  }
+}
+export {
+  matchLines
+};