mergen-server 1.4.0

package/dist/intelligence/pr-policy-gate.js

@@ -0,0 +1,38 @@
+import { evaluateEnterprisePolicy } from "./enterprise-policy-engine.js";
+const MAX_LINES_SCANNED = 2e3;
+function addedLines(patch) {
+  return patch.split("\n").filter((line) => line.startsWith("+") && !line.startsWith("+++")).map((line) => line.slice(1).trim()).filter((line) => line.length > 0);
+}
+function evaluatePRDiff(files, service, policyOverride) {
+  const blockMatches = [];
+  const holdMatches = [];
+  let linesScanned = 0;
+  let truncated = false;
+  let verdict = "pass";
+  outer:
+    for (const file of files) {
+      if (!file.patch) continue;
+      for (const line of addedLines(file.patch)) {
+        if (linesScanned >= MAX_LINES_SCANNED) {
+          truncated = true;
+          break outer;
+        }
+        linesScanned++;
+        const result = evaluateEnterprisePolicy(
+          { files: [file.filename], commands: [line], actor: "ci", service },
+          policyOverride
+        );
+        if (result.verdict === "block") {
+          verdict = "block";
+          blockMatches.push({ file: file.filename, line, verdict: "block", reasons: result.reasons, triggeredRules: result.triggeredRules });
+        } else if (result.verdict === "warn") {
+          if (verdict !== "block") verdict = "warn";
+          holdMatches.push({ file: file.filename, line, verdict: "warn", reasons: result.reasons, triggeredRules: result.triggeredRules });
+        }
+      }
+    }
+  return { verdict, blockMatches, holdMatches, linesScanned, truncated };
+}
+export {
+  evaluatePRDiff
+};

package/dist/intelligence/pr-shadow-analyzer.js

@@ -0,0 +1,229 @@
+import path from "path";
+import { commitContextStore } from "../sensor/commit-context-store.js";
+import { incidentStore } from "../sensor/incident-store.js";
+import { recordPRShadow } from "../sensor/pr-shadow-store.js";
+import { getOverrideSummary } from "./override-corpus.js";
+import { hybridSearch } from "./postmortem-retrieval.js";
+import { memoryStore } from "../datadog/memory-store.js";
+import logger from "../sensor/logger.js";
+const STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "are",
+  "but",
+  "not",
+  "you",
+  "all",
+  "can",
+  "was",
+  "one",
+  "have",
+  "from",
+  "had",
+  "has",
+  "his",
+  "her",
+  "its",
+  "add",
+  "fix",
+  "use",
+  "update",
+  "this",
+  "that",
+  "with",
+  "into",
+  "feat",
+  "chore",
+  "refactor",
+  "docs",
+  "test"
+]);
+function tokenize(text) {
+  return new Set(
+    text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w))
+  );
+}
+function overlapScore(query, doc) {
+  if (query.size === 0 || doc.size === 0) return 0;
+  let overlap = 0;
+  for (const t of query) {
+    if (doc.has(t)) overlap++;
+  }
+  return overlap / Math.max(query.size, 3);
+}
+function truncate(s, n) {
+  return s.length > n ? s.slice(0, n - 1) + "\u2026" : s;
+}
+function buildComment(prTitle, matchedContextResults, matchedIncidentResults, operationalConstraints, fileDangerMatches) {
+  const lines = [
+    "## \u{1F50D} Mergen Context",
+    ""
+  ];
+  if (fileDangerMatches.length > 0) {
+    lines.push("**Files with production incident history:**");
+    for (const f of fileDangerMatches.slice(0, 5)) {
+      const parts = [];
+      if (f.memoryIncidents > 0) {
+        parts.push(`${f.memoryIncidents} tracked incident${f.memoryIncidents !== 1 ? "s" : ""}`);
+      }
+      if (f.postmortems.length > 0) {
+        const pm = f.postmortems[0];
+        parts.push(`corpus: ${truncate(pm.rootCause, 60)} (${Math.round(pm.confidence * 100)}% conf \xB7 ${pm.service})`);
+      }
+      lines.push(`- \`${f.file}\` \u2014 ${parts.join("; ")}`);
+    }
+    lines.push("");
+  }
+  if (matchedIncidentResults.length > 0) {
+    lines.push("**Related incidents from memory:**");
+    for (const inc of matchedIncidentResults.slice(0, 3)) {
+      const when = inc.daysAgo === 0 ? "today" : `${inc.daysAgo}d ago`;
+      const pct = Math.round(inc.confidence * 100);
+      const outcome = inc.causallyCorrect ? " \xB7 \u2705 fix confirmed" : inc.resolvedAutonomously ? " \xB7 \u2699\uFE0F auto-resolved" : "";
+      lines.push(`- ${inc.hypothesis} _(${pct}% confidence \xB7 ${when}${outcome})_`);
+    }
+    lines.push("");
+  }
+  if (matchedContextResults.length > 0) {
+    lines.push("**Historical PR context:**");
+    for (const ctx of matchedContextResults.slice(0, 3)) {
+      const ref = ctx.prNumber ? `#${ctx.prNumber}` : "direct push";
+      const when = ctx.daysAgo === 0 ? "today" : `${ctx.daysAgo}d ago`;
+      const aiTag = ctx.aiGenerated ? " \xB7 \u{1F916} AI-generated" : "";
+      lines.push(`- ${ref}: **${ctx.title}** \u2014 @${ctx.author} _(${when}${aiTag})_`);
+      if (ctx.rationale) {
+        const firstSentence = ctx.rationale.split(/[.\n]/)[0]?.trim();
+        if (firstSentence && firstSentence.length > 10) {
+          lines.push(`  > ${firstSentence.slice(0, 160)}`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  if (operationalConstraints.length > 0) {
+    lines.push("**Operational constraints on this service:**");
+    for (const c of operationalConstraints.slice(0, 3)) {
+      lines.push(`- \`${c.tag}\` overridden ${c.count}\xD7 \u2014 top reason: \`${c.topReason}\``);
+    }
+    lines.push("");
+  }
+  lines.push("_[Mergen shadow mode \u2014 not posted yet]_");
+  return lines.join("\n");
+}
+async function analyzePRForShadow(input) {
+  const { repo, prNumber, prTitle, prBody, author, branch, action, changedFiles = [] } = input;
+  const serviceName = repo.split("/").pop() ?? repo;
+  const queryText = [prTitle, prBody ?? ""].join(" ");
+  const queryTokens = tokenize(queryText);
+  const historicalPRs = commitContextStore.listByRepo(repo, 30);
+  const now = Date.now();
+  const DAY_MS = 864e5;
+  const contextMatches = [];
+  for (const ctx of historicalPRs) {
+    if (ctx.prNumber === prNumber) continue;
+    const docText = [ctx.prTitle ?? "", ctx.prBody ?? ""].join(" ");
+    const docTokens = tokenize(docText);
+    const score = overlapScore(queryTokens, docTokens);
+    if (score >= 0.15) {
+      contextMatches.push({
+        score,
+        title: ctx.prTitle ?? "(no title)",
+        author: ctx.author ?? "unknown",
+        prNumber: ctx.prNumber,
+        daysAgo: Math.floor((now - (ctx.mergedAt ?? ctx.capturedAt)) / DAY_MS),
+        rationale: ctx.prBody ?? null,
+        aiGenerated: ctx.aiGenerated ?? false
+      });
+    }
+  }
+  contextMatches.sort((a, b) => b.score - a.score);
+  const topContextMatches = contextMatches.slice(0, 5);
+  const contextScore = topContextMatches.length === 0 ? 0 : Math.min(1, topContextMatches[0].score * 1.5);
+  const recentIncidents = incidentStore.list(void 0, 100);
+  const incidentMatches = [];
+  const serviceNameLower = serviceName.toLowerCase();
+  for (const inc of recentIncidents) {
+    const serviceMatch = (inc.service ?? "").toLowerCase() === serviceNameLower || (inc.hypothesis ?? "").toLowerCase().includes(serviceNameLower);
+    if (serviceMatch) {
+      incidentMatches.push({
+        hypothesis: inc.hypothesis,
+        daysAgo: Math.floor((now - inc.createdAt) / DAY_MS),
+        confidence: inc.confidence,
+        resolvedAutonomously: inc.resolvedAutonomously ?? false,
+        causallyCorrect: inc.causallyCorrect ?? false
+      });
+    }
+  }
+  incidentMatches.sort((a, b) => a.daysAgo - b.daysAgo || b.confidence - a.confidence);
+  const topIncidentMatches = incidentMatches.slice(0, 3);
+  const incidentScore = topIncidentMatches.length === 0 ? 0 : Math.min(1, topIncidentMatches.length / 3 + topIncidentMatches[0].confidence * 0.5);
+  const fileDangerMatches = [];
+  for (const file of changedFiles.slice(0, 20)) {
+    const base = path.basename(file, path.extname(file));
+    const memIncidents = memoryStore.findByFile(file, 3);
+    let pmMatches = [];
+    if (base.length >= 3) {
+      try {
+        const pmResults = hybridSearch(base, { topK: 2, maxCorpus: 200 });
+        pmMatches = pmResults.map((r) => ({
+          rootCause: r.postmortem.rootCause,
+          confidence: r.postmortem.confidence,
+          service: r.postmortem.service
+        }));
+      } catch {
+      }
+    }
+    if (memIncidents.length > 0 || pmMatches.length > 0) {
+      fileDangerMatches.push({ file, memoryIncidents: memIncidents.length, postmortems: pmMatches });
+    }
+  }
+  const fileDangerScore = fileDangerMatches.length > 0 ? Math.min(0.3, fileDangerMatches.length * 0.15) : 0;
+  const relevanceScore = Math.min(
+    1,
+    Math.round((contextScore * 0.5 + incidentScore * 0.3 + fileDangerScore * 0.2) * 1e3) / 1e3
+  );
+  const matchedIncidents = topIncidentMatches.length;
+  const matchedContexts = topContextMatches.length;
+  const triggeredBy = [];
+  if (matchedIncidents > 0) triggeredBy.push("incident_match");
+  if (topContextMatches.some((c) => c.score >= 0.3)) triggeredBy.push("context_match");
+  if (historicalPRs.length >= 10) triggeredBy.push("rich_history");
+  if (fileDangerMatches.length > 0) triggeredBy.push("file_danger_match");
+  const wouldHaveShown = matchedIncidents >= 1 && relevanceScore >= 0.7 || fileDangerMatches.length >= 1;
+  const overrideSummary = getOverrideSummary().filter((s) => s.services.includes(serviceName)).map((s) => ({
+    tag: s.tag,
+    topReason: s.dominantReason ?? "other",
+    count: s.total
+  }));
+  const wouldHaveComment = wouldHaveShown ? buildComment(prTitle, topContextMatches, topIncidentMatches, overrideSummary, fileDangerMatches) : null;
+  const result = recordPRShadow({
+    prId: `${repo}#${prNumber}`,
+    repo,
+    prNumber,
+    prTitle,
+    author,
+    branch,
+    action,
+    wouldHaveShown,
+    relevanceScore,
+    matchedIncidents,
+    matchedContexts,
+    triggeredBy,
+    wouldHaveComment
+  });
+  logger.info(
+    {
+      prId: result.prId,
+      wouldHaveShown,
+      relevanceScore,
+      matchedIncidents,
+      matchedContexts
+    },
+    "pr-shadow: analysis complete"
+  );
+  return result;
+}
+export {
+  analyzePRForShadow
+};

package/dist/intelligence/process-tree.js

@@ -0,0 +1,108 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import logger from "../sensor/logger.js";
+const execFileAsync = promisify(execFile);
+async function listAllProcessesPosix() {
+  const { stdout } = await execFileAsync("ps", ["-A", "-o", "pid=,ppid=,command="]);
+  const rows = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const match = trimmed.match(/^(\d+)\s+(\d+)\s+(.*)$/);
+    if (!match) continue;
+    rows.push({ pid: Number(match[1]), ppid: Number(match[2]), command: match[3] });
+  }
+  return rows;
+}
+async function listAllProcessesWindows() {
+  const { stdout } = await execFileAsync("powershell", [
+    "-NoProfile",
+    "-Command",
+    "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine | ConvertTo-Json -Compress"
+  ]);
+  const parsed = JSON.parse(stdout || "[]");
+  const list = Array.isArray(parsed) ? parsed : [parsed];
+  return list.map((p) => ({ pid: p.ProcessId, ppid: p.ParentProcessId, command: p.CommandLine ?? "" }));
+}
+async function listAllProcesses() {
+  return process.platform === "win32" ? listAllProcessesWindows() : listAllProcessesPosix();
+}
+async function listDescendants(rootPid) {
+  let all;
+  try {
+    all = await listAllProcesses();
+  } catch (err) {
+    logger.warn({ err }, "process-tree: failed to list processes \u2014 descendant monitoring degraded to no-op");
+    return [];
+  }
+  const byParent = /* @__PURE__ */ new Map();
+  for (const p of all) {
+    if (!byParent.has(p.ppid)) byParent.set(p.ppid, []);
+    byParent.get(p.ppid).push(p);
+  }
+  const descendants = [];
+  const queue = [rootPid];
+  const seen = /* @__PURE__ */ new Set([rootPid]);
+  while (queue.length > 0) {
+    const pid = queue.shift();
+    for (const child of byParent.get(pid) ?? []) {
+      if (seen.has(child.pid)) continue;
+      seen.add(child.pid);
+      descendants.push(child);
+      queue.push(child.pid);
+    }
+  }
+  return descendants;
+}
+function watchDescendants(rootPid, opts) {
+  const intervalMs = opts.intervalMs ?? 250;
+  const seenPids = /* @__PURE__ */ new Set();
+  let stopped = false;
+  const tick = async () => {
+    if (stopped) return;
+    const descendants = await listDescendants(rootPid);
+    for (const d of descendants) {
+      if (!seenPids.has(d.pid)) {
+        seenPids.add(d.pid);
+        opts.onSpawn(d);
+      }
+    }
+    if (!stopped) {
+      handle = setTimeout(tick, intervalMs);
+      handle.unref?.();
+    }
+  };
+  let handle = setTimeout(tick, intervalMs);
+  handle.unref?.();
+  return {
+    stop: () => {
+      stopped = true;
+      clearTimeout(handle);
+    }
+  };
+}
+async function killTree(rootPid) {
+  if (process.platform === "win32") {
+    try {
+      await execFileAsync("taskkill", ["/PID", String(rootPid), "/T", "/F"]);
+    } catch {
+    }
+    return;
+  }
+  const descendants = await listDescendants(rootPid);
+  for (const d of [...descendants].reverse()) {
+    try {
+      process.kill(d.pid, "SIGKILL");
+    } catch {
+    }
+  }
+  try {
+    process.kill(rootPid, "SIGKILL");
+  } catch {
+  }
+}
+export {
+  killTree,
+  listDescendants,
+  watchDescendants
+};

package/dist/intelligence/prompts.js

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

package/dist/intelligence/replay.js

@@ -0,0 +1,38 @@
+import { getGateEvents } from "./gate-analytics.js";
+import { getStores } from "../storage/store-registry.js";
+function fromGateEvent(e) {
+  return {
+    ts: e.ts,
+    source: "gate-event",
+    toolName: e.toolName,
+    command: e.command,
+    verdict: e.verdict,
+    blunderType: null,
+    triggeredRules: e.triggeredRules,
+    service: e.service,
+    agentId: e.agentId
+  };
+}
+async function buildReplay(traceId) {
+  const gateEvents = getGateEvents().filter((e) => e.traceId === traceId);
+  const allBlunders = await getStores().blunders.list();
+  const blunders = allBlunders.filter((b) => b.traceId === traceId);
+  const entries = [
+    ...gateEvents.map(fromGateEvent),
+    ...blunders.map((b) => ({
+      ts: b.recordedAt,
+      source: "blunder-log",
+      toolName: null,
+      command: b.command,
+      verdict: null,
+      blunderType: b.blunderType,
+      triggeredRules: b.triggeredRules ?? null,
+      service: b.service,
+      agentId: b.agentId ?? null
+    }))
+  ].sort((a, b) => a.ts - b.ts);
+  return { traceId, entries, gateEventCount: gateEvents.length, blunderCount: blunders.length };
+}
+export {
+  buildReplay
+};

package/dist/intelligence/repro-steps.js

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

package/dist/intelligence/resource-file-context.js

@@ -0,0 +1,138 @@
+import path from "path";
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { memoryStore, formatMttr } from "../datadog/memory-store.js";
+import { getActiveIncident } from "../datadog/incident-state.js";
+import { getCurrentTraceContext } from "../datadog/otel-trace.js";
+import { hybridSearch } from "./postmortem-retrieval.js";
+import { getOverrideSummary } from "./override-corpus.js";
+import logger from "../sensor/logger.js";
+function registerFileContextResource(server) {
+  const template = new ResourceTemplate("mergen://file/{+path}", { list: void 0 });
+  server.resource(
+    "file-context",
+    template,
+    async (uri, variables) => {
+      const filePath = decodeURIComponent(String(variables["path"] ?? ""));
+      if (!filePath) {
+        return {
+          contents: [{ uri: uri.href, mimeType: "text/plain", text: "# No file path provided" }]
+        };
+      }
+      const sections = [];
+      const active = getActiveIncident();
+      if (active) {
+        const isImplicated = active.implicatedFile && (active.implicatedFile.endsWith(filePath) || filePath.endsWith(active.implicatedFile.split("/").pop() ?? ""));
+        if (isImplicated) {
+          sections.push(
+            `## \u{1F6A8} ACTIVE INCIDENT \u2014 THIS FILE IS IMPLICATED
+
+**Alert:** ${active.alertTitle}
+**Trace:** \`${active.traceId}\`
+**File/Line:** \`${active.implicatedFile}:${active.implicatedLine ?? "?"}\`
+**Fired:** ${new Date(active.firedAt).toISOString()}
+
+> Do not refactor this file while the incident is open.
+`
+          );
+        } else {
+          sections.push(
+            `## \u26A0\uFE0F ACTIVE INCIDENT (different file)
+
+**Alert:** ${active.alertTitle} \u2014 implicated: \`${active.implicatedFile ?? "unknown"}\`
+`
+          );
+        }
+      }
+      const history = memoryStore.findByFile(filePath, 8);
+      if (history.length > 0) {
+        const lines = [`## Production Incident History for \`${filePath}\`
+`];
+        for (const rec of history) {
+          const age = formatAge(rec.firedAt);
+          const mttr = rec.mttrMs ? formatMttr(rec.mttrMs) : "open";
+          const pr = rec.fixPrUrl ? ` \u2192 [fix PR](${rec.fixPrUrl})` : "";
+          lines.push(
+            `- **${rec.pdAlertTitle}** (${age} ago, MTTR ${mttr})  
+  \`${rec.errorType}: ${truncate(rec.errorMessage, 80)}\`${pr}`
+          );
+        }
+        sections.push(lines.join("\n"));
+        const topFp = history[0]?.fingerprint;
+        if (topFp) {
+          const bench = memoryStore.benchmarkStats(topFp);
+          if (bench && bench.occurrences >= 2) {
+            sections.push(
+              `## Pattern Stats (fingerprint \`${topFp}\`)
+
+- Occurrences: **${bench.occurrences}**
+- p50 MTTR: **${bench.p50MttrMs ? formatMttr(bench.p50MttrMs) : "n/a"}**
+- p90 MTTR: **${bench.p90MttrMs ? formatMttr(bench.p90MttrMs) : "n/a"}**
+- Most common fix: **${bench.topResolutionType}** (${bench.topResolutionCount}\xD7)
+`
+            );
+          }
+        }
+      } else {
+        sections.push(`## Production Incident History
+
+No incidents on record for \`${filePath}\`.`);
+      }
+      const basename = path.basename(filePath, path.extname(filePath));
+      if (basename.length >= 3) {
+        const pmResults = hybridSearch(basename, { topK: 3, maxCorpus: 200 });
+        if (pmResults.length > 0) {
+          const lines = [`## Corpus Postmortems (related to \`${filePath}\`)
+`];
+          for (const r of pmResults) {
+            const pm = r.postmortem;
+            const age = formatAge(pm.generatedAt);
+            const auto = pm.resolvedAutonomously ? " \xB7 auto-resolved" : "";
+            const fix = pm.fixCommand ? `
+  Fix: \`${truncate(pm.fixCommand, 80)}\`` : "";
+            lines.push(
+              `- **[${pm.service}] ${truncate(pm.rootCause, 100)}** _(${age} ago${auto}, ${Math.round(pm.confidence * 100)}% confidence)_${fix}`
+            );
+          }
+          sections.push(lines.join("\n"));
+        }
+      }
+      const overrides = getOverrideSummary().slice(0, 5);
+      if (overrides.length > 0) {
+        const lines = ["## Override Corpus \u2014 Active Constraints\n"];
+        for (const o of overrides) {
+          const timeNote = o.timePattern ? ` \xB7 ${o.timePattern}` : "";
+          const svcs = o.services.length > 0 ? ` \xB7 services: ${o.services.slice(0, 3).map((s) => `\`${s}\``).join(", ")}` : "";
+          lines.push(
+            `- \`${o.tag}\` \u2014 overridden **${o.total}\xD7** \xB7 top reason: \`${o.dominantReason ?? "other"}\`${timeNote}${svcs}`
+          );
+        }
+        lines.push("\n_Check if any of these constraints apply before modifying this file._");
+        sections.push(lines.join("\n"));
+      }
+      const ctx = getCurrentTraceContext();
+      sections.push(
+        `## Mergen Trace Context
+
+\`traceparent: ${ctx.traceparent}\``
+      );
+      const text = sections.join("\n\n---\n\n");
+      logger.debug({ filePath, historyCount: history.length }, "file-context resource served");
+      return {
+        contents: [{ uri: uri.href, mimeType: "text/markdown", text }]
+      };
+    }
+  );
+}
+function formatAge(ms) {
+  const diff = Date.now() - ms;
+  if (diff < 6e4) return `${Math.round(diff / 1e3)}s`;
+  if (diff < 36e5) return `${Math.round(diff / 6e4)}m`;
+  if (diff < 864e5) return `${Math.round(diff / 36e5)}h`;
+  return `${Math.round(diff / 864e5)}d`;
+}
+function truncate(s, n) {
+  return s.length > n ? s.slice(0, n - 1) + "\u2026" : s;
+}
+export {
+  registerFileContextResource
+};

package/dist/intelligence/risk-score.js

@@ -0,0 +1,22 @@
+function computeRiskScore(inputs, holdThreshold) {
+  let score = 0;
+  if (!inputs.blastReversible) score += inputs.blastDataAtRisk ? 0.4 : 0.2;
+  if (inputs.blastScope === "data-destructive") score += 0.15;
+  if (inputs.contaminated) score += 0.3;
+  if (inputs.scrutinyTier === "high") score += 0.3;
+  else if (inputs.scrutinyTier === "elevated") score += 0.15;
+  score += Math.min(0.15, inputs.similarIncidentCount * 0.05);
+  const riskScore = Math.min(1, Math.round(score * 1e3) / 1e3);
+  return { riskScore, escalateToHold: riskScore >= holdThreshold };
+}
+function getRiskHoldThreshold() {
+  const raw = process.env.MERGEN_RISK_HOLD_THRESHOLD;
+  if (!raw) return null;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 1) return null;
+  return parsed;
+}
+export {
+  computeRiskScore,
+  getRiskHoldThreshold
+};