@neat.is/core 0.9.7-dev.20260827 → 0.9.7

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   routeSpanToProject,
   startDaemon
-} from "./chunk-XYAZOGEX.js";
+} from "./chunk-JSUPWMH3.js";
 import {
   ProjectNameCollisionError,
   addProject,
@@ -37,7 +37,7 @@ import {
   thresholdForEdgeType,
   touchLastSeen,
   writeAtomically
-} from "./chunk-XOGTJVUM.js";
+} from "./chunk-KZBFP7L6.js";
 import {
   startOtelGrpcReceiver
 } from "./chunk-ERE47MCR.js";

package/dist/neatd.cjs

@@ -16847,6 +16847,139 @@ function detectSymbolMismatches(graph, incidents) {
   }
   return out;
 }
+var OBSERVED_FAILING_ERROR_RATE = 0.5;
+var OBSERVED_FAILING_MIN_SPANS = 5;
+var OBSERVED_FAILING_CONFIDENCE = 0.6;
+function detectObservedFailingEdge(graph, bucket) {
+  if (!bucket.extracted || !bucket.observed) return [];
+  if (!OBSERVABLE_EDGE_TYPES.has(bucket.type)) return [];
+  if (bucket.observed.provenance !== import_types58.Provenance.OBSERVED) return [];
+  const signal = bucket.observed.signal;
+  if (!signal) return [];
+  const { spanCount, errorCount } = signal;
+  if (spanCount < OBSERVED_FAILING_MIN_SPANS) return [];
+  const errorRate = errorCount / spanCount;
+  if (errorRate < OBSERVED_FAILING_ERROR_RATE) return [];
+  const pct = Math.round(errorRate * 100);
+  return [
+    {
+      type: "observed-failing",
+      source: bucket.source,
+      target: bucket.target,
+      failureKind: "error-rate",
+      provenance: import_types58.Provenance.INFERRED,
+      edgeType: bucket.type,
+      observed: bucket.observed,
+      spanCount,
+      errorCount,
+      errorRate: clampConfidence(errorRate),
+      confidence: OBSERVED_FAILING_CONFIDENCE,
+      reason: `Code declares ${bucket.source} \u2192 ${bucket.target} (${bucket.type}) and production observes it, but ${errorCount}/${spanCount} observed calls fail (${pct}% error rate) \u2014 the declared dependency is predominantly failing. The declared intent (EXTRACTED) and the observed behaviour (OBSERVED) diverge.`,
+      recommendation: "Treat this as a broken declared dependency, not a coverage gap: production runs the call the code declares and most calls error. Check the dependency\u2019s health, recent deploys, and the observed error responses on this edge."
+    }
+  ];
+}
+var OBSERVED_FAILURE_PATTERNS = [
+  {
+    kind: "connection-refused",
+    patterns: [/\bECONNREFUSED\b/i, /\bconnection refused\b/i]
+  },
+  {
+    kind: "deadline-exceeded",
+    patterns: [/\bDEADLINE_EXCEEDED\b/i, /\bdeadline exceeded\b/i]
+  },
+  {
+    kind: "timeout",
+    patterns: [/\bETIMEDOUT\b/i, /\btimed[\s-]?out\b/i, /\btimeout\b/i]
+  },
+  {
+    kind: "unavailable",
+    patterns: [
+      /\bUNAVAILABLE\b/i,
+      /\bservice unavailable\b/i,
+      /\bECONNRESET\b/i,
+      /\bconnection reset\b/i,
+      /\bno healthy upstream\b/i
+    ]
+  }
+];
+function classifyObservedFailure(ev) {
+  const haystack = [ev.errorType, ev.exceptionType, ev.errorMessage].filter((s) => typeof s === "string").join(" \n ");
+  for (const entry2 of OBSERVED_FAILURE_PATTERNS) {
+    for (const re of entry2.patterns) {
+      if (re.test(haystack)) return entry2.kind;
+    }
+  }
+  const code = ev.httpStatusCode;
+  if (typeof code === "number" && code >= 500 && code < 600) return "server-error";
+  return null;
+}
+function observedFailureLabel(kind) {
+  switch (kind) {
+    case "error-rate":
+      return "a high error rate";
+    case "connection-refused":
+      return "a refused connection";
+    case "deadline-exceeded":
+      return "a deadline exceeded";
+    case "timeout":
+      return "a timeout";
+    case "unavailable":
+      return "an unavailable or reset connection";
+    case "server-error":
+      return "a server error (5xx)";
+  }
+}
+function detectObservedFailingIncidents(graph, incidents) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const ev of incidents) {
+    const kind = classifyObservedFailure(ev);
+    if (!kind) continue;
+    const locus = symbolLocus(graph, ev);
+    if (!locus) continue;
+    const key = `${locus.node}|${kind}`;
+    const existing = groups.get(key);
+    if (!existing) {
+      groups.set(key, {
+        node: locus.node,
+        kind,
+        ...locus.location ? { location: locus.location } : {},
+        latest: ev,
+        count: 1,
+        ...typeof ev.httpStatusCode === "number" ? { httpStatusCode: ev.httpStatusCode } : {}
+      });
+    } else {
+      existing.count += 1;
+      if (ev.timestamp.localeCompare(existing.latest.timestamp) > 0) {
+        existing.latest = ev;
+        if (locus.location) existing.location = locus.location;
+        if (typeof ev.httpStatusCode === "number") existing.httpStatusCode = ev.httpStatusCode;
+      }
+    }
+  }
+  const out = [];
+  for (const g of groups.values()) {
+    const where = g.location ? ` at ${g.location}` : "";
+    const label = observedFailureLabel(g.kind);
+    const times = g.count > 1 ? ` (${g.count} recorded incidents)` : " (1 recorded incident)";
+    out.push({
+      type: "observed-failing",
+      source: g.node,
+      target: g.node,
+      failureKind: g.kind,
+      provenance: import_types58.Provenance.INFERRED,
+      ...g.location ? { location: g.location } : {},
+      incidentId: g.latest.id,
+      errorMessage: g.latest.errorMessage,
+      incidentCount: g.count,
+      ...typeof g.httpStatusCode === "number" ? { httpStatusCode: g.httpStatusCode } : {},
+      confidence: OBSERVED_FAILING_CONFIDENCE,
+      reason: `Code${where} declares an external call that production observes failing \u2014 ${g.latest.service} recorded ${label}: "${g.latest.errorMessage}"${times}. The declared call (EXTRACTED) and the observed failure (OBSERVED) diverge \u2014 the dependency is reached and does not work.`,
+      recommendation: `The declared call is running in production and failing at the transport or response level (${label}). Check the target host/endpoint the code reaches, connectivity, and the call\u2019s deadline \u2014 a wrong or unreachable host and an exceeded deadline both land here.`
+    });
+  }
+  return out;
+}
 function involvesNode(d, nodeId) {
   return d.source === nodeId || d.target === nodeId;
 }
@@ -16919,6 +17052,7 @@ function computeDivergences(graph, opts = {}) {
   const buckets2 = bucketEdges(graph);
   for (const bucket of buckets2.values()) {
     for (const d of detectMissingDivergences(graph, bucket)) all.push(d);
+    for (const d of detectObservedFailingEdge(graph, bucket)) all.push(d);
   }
   graph.forEachNode((nodeId, attrs) => {
     const n = attrs;
@@ -16934,6 +17068,7 @@ function computeDivergences(graph, opts = {}) {
   });
   if (opts.incidents && opts.incidents.length > 0) {
     for (const d of detectSymbolMismatches(graph, opts.incidents)) all.push(d);
+    for (const d of detectObservedFailingIncidents(graph, opts.incidents)) all.push(d);
   }
   const reconciled = suppressHostMismatchHalves(all);
   const dampened = dampenDeadCodeProbes(graph, buckets2, reconciled);
@@ -16960,7 +17095,12 @@ function computeDivergences(graph, opts = {}) {
     // type; this only breaks a confidence tie, and it orders last so a same-
     // confidence edge finding leads. In practice it carries the INFERRED grade
     // (0.6), so it sits below the high-confidence edge divergences already.
-    "observed-symbol-mismatch": 5
+    "observed-symbol-mismatch": 5,
+    // Behavioral-failure (ADR-220) also carries the INFERRED grade (0.6); it
+    // orders last so at equal confidence the structural and symbol divergences
+    // lead, per the contract ("rank below the definitive structural and symbol
+    // divergences").
+    "observed-failing": 6
   };
   filtered.sort((a, b) => {
     if (b.confidence !== a.confidence) return b.confidence - a.confidence;
@@ -16974,7 +17114,13 @@ function computeDivergences(graph, opts = {}) {
     if (ac !== bc) return ac.localeCompare(bc);
     const asym = "symbol" in a && a.symbol ? a.symbol : "";
     const bsym = "symbol" in b && b.symbol ? b.symbol : "";
-    return asym.localeCompare(bsym);
+    if (asym !== bsym) return asym.localeCompare(bsym);
+    const afk = "failureKind" in a && a.failureKind ? a.failureKind : "";
+    const bfk = "failureKind" in b && b.failureKind ? b.failureKind : "";
+    if (afk !== bfk) return afk.localeCompare(bfk);
+    const aloc = "location" in a && a.location ? a.location : "";
+    const bloc = "location" in b && b.location ? b.location : "";
+    return aloc.localeCompare(bloc);
   });
   return import_types58.DivergenceResultSchema.parse({
     divergences: filtered,
@@ -17406,6 +17552,10 @@ function divergenceLine(d) {
     const member = d.symbol ? ` ${d.symbol}` : "";
     return `[${d.type}] ${d.source}${member}${at} \u2014 ${d.reason}`;
   }
+  if (d.type === "observed-failing" && !d.edgeType) {
+    const at = d.location ? ` at ${d.location}` : "";
+    return `[${d.type}] ${d.source}${at} \u2014 ${d.reason}`;
+  }
   return `[${d.type}] ${d.source} \u2192 ${d.target} \u2014 ${d.reason}`;
 }
 function buildDivergenceSection(graph, node, incidents) {