@neat.is/core 0.9.8-dev.20260828 → 0.9.8

package/dist/{chunk-KZBFP7L6.js → chunk-G4A6FCKG.js}

@@ -931,6 +931,7 @@ import {
   frontierId,
   graphqlOperationId,
   grpcMethodId,
+  incidentKindOf,
   inferredEdgeId,
   infraId,
   observedEdgeId,
@@ -4580,11 +4581,25 @@ function upsertInferredEdge(graph, type, source, target, ts) {
   };
   graph.addEdgeWithKey(id, source, target, edge);
 }
+function emitIncidentEvent(project, ev) {
+  emitNeatEvent({
+    type: "incident",
+    project,
+    payload: {
+      incidentId: ev.id,
+      affectedNode: ev.affectedNode,
+      service: ev.service,
+      incidentKind: incidentKindOf(ev),
+      at: ev.timestamp
+    }
+  });
+}
 async function appendErrorEvent(ctx, ev) {
   await fs7.mkdir(path8.dirname(ctx.errorsPath), { recursive: true });
   await fs7.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  emitIncidentEvent(ctx.project ?? DEFAULT_PROJECT, ev);
 }
-async function appendConnectorIncident(errorsPath, input) {
+async function appendConnectorIncident(errorsPath, input, project) {
   const ev = {
     id: input.id,
     timestamp: input.timestamp,
@@ -4598,6 +4613,7 @@ async function appendConnectorIncident(errorsPath, input) {
   };
   await fs7.mkdir(path8.dirname(errorsPath), { recursive: true });
   await fs7.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  if (project) emitIncidentEvent(project, ev);
 }
 function landIncidentCallSite(span, callSite, trusted, graph) {
   const relPath = graph ? reconcileObservedRelPath(graph, span.service, callSite.relPath) : callSite.relPath;
@@ -4691,12 +4707,13 @@ function buildErrorEventForReceiver(span, graph, scanPath) {
     affectedNode: locus.affectedNode
   };
 }
-function makeErrorSpanWriter(errorsPath, graph, scanPath) {
+function makeErrorSpanWriter(errorsPath, graph, scanPath, project = DEFAULT_PROJECT) {
   return async (span) => {
     const ev = buildErrorEventForReceiver(span, graph, scanPath);
     if (!ev) return;
     await fs7.mkdir(path8.dirname(errorsPath), { recursive: true });
     await fs7.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+    emitIncidentEvent(project, ev);
   };
 }
 async function recordFailingResponseIncident(ctx, span, affectedNode, timestamp, statusCode, count, firstTimestamp) {
@@ -16931,8 +16948,130 @@ function queryLogEntries(opts) {
   return merged;
 }
 
+// src/goodybag.ts
+import {
+  IncidentCardSchema,
+  Provenance as Provenance26,
+  incidentKindOf as incidentKindOf2
+} from "@neat.is/types";
+var CODE_FILEPATH_ATTR2 = "code.filepath";
+var CODE_LINENO_ATTR2 = "code.lineno";
+var BLAST_NEAREST_LIMIT = 5;
+function grainOf2(graph, nodeId) {
+  if (graph.hasNode(nodeId)) {
+    const t = graph.getNodeAttributes(nodeId).type;
+    if (typeof t === "string" && t.length > 0) {
+      return (t.endsWith("Node") ? t.slice(0, -4) : t).toLowerCase();
+    }
+  }
+  const colon = nodeId.indexOf(":");
+  return colon > 0 ? nodeId.slice(0, colon) : "unknown";
+}
+function locusOf(graph, ev) {
+  const file = ev.attributes?.[CODE_FILEPATH_ATTR2];
+  if (typeof file !== "string" || file.length === 0) return null;
+  const rawLine = ev.attributes?.[CODE_LINENO_ATTR2];
+  const line = typeof rawLine === "number" ? rawLine : Number(rawLine);
+  const node = graph.hasNode(ev.affectedNode) ? graph.getNodeAttributes(ev.affectedNode) : void 0;
+  return {
+    file,
+    ...Number.isFinite(line) ? { lineStart: line, lineEnd: line } : {},
+    ...node?.name ? { symbol: node.name } : {},
+    service: node?.service ?? ev.service,
+    provenance: Provenance26.OBSERVED
+  };
+}
+function divergenceSummary(d) {
+  const column = "column" in d && d.column ? `.${d.column}` : "";
+  const label = "table" in d && d.table ? `${d.table}${column}` : `${d.source} \u2192 ${d.target}`;
+  return label;
+}
+function baseName(p) {
+  const parts = p.split(/[\\/]/);
+  return parts[parts.length - 1] || p;
+}
+function shortLabel(graph, nodeId) {
+  if (graph.hasNode(nodeId)) {
+    const name = graph.getNodeAttributes(nodeId).name;
+    if (typeof name === "string" && name.length > 0) return name;
+  }
+  const afterHash = nodeId.includes("#") ? nodeId.slice(nodeId.lastIndexOf("#") + 1) : nodeId;
+  return afterHash.includes(":") ? afterHash.slice(afterHash.lastIndexOf(":") + 1) : afterHash;
+}
+function renderHeadline(graph, ev, locus, causeNode) {
+  const what = ev.exceptionType ? `raised ${ev.exceptionType}` : ev.errorMessage || "failed";
+  const cause = causeNode && causeNode !== ev.affectedNode ? ` \u2192 root cause ${shortLabel(graph, causeNode)}` : "";
+  if (locus) {
+    const base = baseName(locus.file);
+    const lines = locus.lineStart != null ? locus.lineEnd && locus.lineEnd !== locus.lineStart ? `LINES ${locus.lineStart}-${locus.lineEnd}` : `LINE ${locus.lineStart}` : "";
+    const symbol = locus.symbol ?? (grainOf2(graph, ev.affectedNode) === "symbol" ? shortLabel(graph, ev.affectedNode) : void 0);
+    const subject = symbol ? `SYMBOL ${symbol}` : `FILE ${base}`;
+    const at = symbol ? `${lines ? `${lines} in ` : ""}${base}` : lines;
+    const where = at ? ` at ${at}` : "";
+    return `${subject}${where} (SERVICE ${ev.service}) ${what} at ${ev.timestamp}${cause}`;
+  }
+  return `SERVICE ${ev.service} ${what} at ${ev.timestamp}${cause}`;
+}
+function buildIncidentCard(graph, errorEvent, incidents, policies) {
+  const affected = errorEvent.affectedNode;
+  const locus = locusOf(graph, errorEvent);
+  const inGraph = graph.hasNode(affected);
+  const rc = inGraph ? getRootCause(graph, affected, errorEvent, incidents) : null;
+  let rootCause = null;
+  if (rc) {
+    const provs = rc.edgeProvenances ?? [];
+    const chain = (rc.traversalPath ?? []).map((node, i) => ({
+      node,
+      grain: grainOf2(graph, node),
+      provenance: provs[i] ?? provs[provs.length - 1] ?? Provenance26.INFERRED
+    }));
+    rootCause = {
+      node: rc.rootCauseNode,
+      ...rc.candidates?.[0]?.classification ? { classification: rc.candidates[0].classification } : {},
+      reason: rc.rootCauseReason,
+      confidence: rc.confidence,
+      fix: rc.fixRecommendation ?? null,
+      chain
+    };
+  }
+  const blast = inGraph ? getBlastRadius(graph, affected) : { origin: affected, affectedNodes: [], totalAffected: 0 };
+  const nearest = [...blast.affectedNodes].sort((a, b) => a.distance - b.distance).slice(0, BLAST_NEAREST_LIMIT).map((n) => ({ node: n.nodeId, distance: n.distance, provenance: n.edgeProvenance }));
+  const applicable = inGraph ? selectApplicablePolicies(graph, policies, affected) : [];
+  const policyCards = applicable.map((p) => ({
+    policyName: p.policyName,
+    severity: p.severity,
+    message: p.reason
+  }));
+  const divergences = inGraph ? computeDivergences(graph, { node: affected, incidents }).divergences.map((d) => ({
+    type: d.type,
+    summary: divergenceSummary(d)
+  })) : [];
+  const card = {
+    kind: "incident",
+    id: errorEvent.id,
+    at: errorEvent.timestamp,
+    incidentKind: incidentKindOf2(errorEvent),
+    service: errorEvent.service,
+    affectedNode: affected,
+    message: errorEvent.errorMessage,
+    ...errorEvent.exceptionType ? { exceptionType: errorEvent.exceptionType } : {},
+    ...errorEvent.httpStatusCode !== void 0 ? { httpStatusCode: errorEvent.httpStatusCode } : {},
+    ...errorEvent.incidentCount !== void 0 ? { count: errorEvent.incidentCount } : {},
+    ...errorEvent.firstTimestamp && errorEvent.lastTimestamp ? { window: { first: errorEvent.firstTimestamp, last: errorEvent.lastTimestamp } } : {},
+    ...errorEvent.traceId ? { traceId: errorEvent.traceId } : {},
+    ...errorEvent.spanId ? { spanId: errorEvent.spanId } : {},
+    locus,
+    rootCause,
+    ...nearest.length > 0 ? { blastRadius: { totalAffected: blast.totalAffected, nearest } } : {},
+    ...policyCards.length > 0 ? { policies: policyCards } : {},
+    ...divergences.length > 0 ? { divergence: divergences } : {},
+    headline: renderHeadline(graph, errorEvent, locus, rootCause?.node ?? null)
+  };
+  return IncidentCardSchema.parse(card);
+}
+
 // src/ask.ts
-import { AskResultSchema, NodeType as NodeType32, Provenance as Provenance26, serviceId as serviceId14 } from "@neat.is/types";
+import { AskResultSchema, NodeType as NodeType32, Provenance as Provenance27, serviceId as serviceId14 } from "@neat.is/types";
 var DEFAULT_MAX_NODES = 3;
 var MAX_FACTS_PER_SECTION = 6;
 var INTENT_RULES = [
@@ -17217,7 +17356,7 @@ function edgeSignalNote(e) {
 function buildRootCauseSection(graph, node, incidents, now) {
   const result = getRootCause(graph, node, void 0, incidents, { now });
   if (!result) return null;
-  const lastProv = result.edgeProvenances[result.edgeProvenances.length - 1] ?? Provenance26.OBSERVED;
+  const lastProv = result.edgeProvenances[result.edgeProvenances.length - 1] ?? Provenance27.OBSERVED;
   const facts = [
     {
       text: `Root cause: ${result.rootCauseNode} \u2014 ${result.rootCauseReason}`,
@@ -17267,7 +17406,7 @@ function buildObservedSection(graph, node) {
     if (result.observed && result.inboundObservedCount > 0) {
       facts.push({
         text: `no outbound runtime calls, but OTel observed ${result.inboundObservedCount} inbound call path${result.inboundObservedCount === 1 ? "" : "s"} \u2014 a pure receiver`,
-        provenance: Provenance26.OBSERVED
+        provenance: Provenance27.OBSERVED
       });
     } else {
       return null;
@@ -17295,7 +17434,7 @@ function buildIncidentsSection(node, incidents) {
   const facts = ordered.map((ev) => ({
     text: `${ev.timestamp} \u2014 ${ev.service}: ${ev.errorMessage}`,
     // ErrorEvents are observation records — OBSERVED by definition.
-    provenance: Provenance26.OBSERVED
+    provenance: Provenance27.OBSERVED
   }));
   return { heading: `Recent incidents (OBSERVED) \u2014 ${relevant.length} recorded`, facts };
 }
@@ -17370,7 +17509,7 @@ function buildGlobalIncidentsSection(incidents) {
   const rows = [...byKey.values()].sort((a, b) => b.count - a.count || b.latest.localeCompare(a.latest) || a.key.localeCompare(b.key)).slice(0, MAX_FACTS_PER_SECTION);
   const facts = rows.map((r) => ({
     text: `${r.key} \u2014 ${r.count} incident${r.count === 1 ? "" : "s"}, latest ${r.latest}: ${r.sampleMsg}`,
-    provenance: Provenance26.OBSERVED
+    provenance: Provenance27.OBSERVED
   }));
   return {
     heading: `Incidents across the system \u2014 ${incidents.length} recorded`,
@@ -17398,7 +17537,7 @@ function buildOverviewSections(graph, incidents) {
       text: `${count(NodeType32.ServiceNode)} services, ${count(NodeType32.FileNode)} files, ${count(NodeType32.SymbolNode)} symbols, ${count(NodeType32.DatabaseNode)} databases`
     }
   ];
-  for (const p of [Provenance26.EXTRACTED, Provenance26.OBSERVED, Provenance26.INFERRED, Provenance26.STALE]) {
+  for (const p of [Provenance27.EXTRACTED, Provenance27.OBSERVED, Provenance27.INFERRED, Provenance27.STALE]) {
     const n = edgeByProv.get(p) ?? 0;
     if (n > 0) shapeFacts.push({ text: `${n} ${p} edge${n === 1 ? "" : "s"}`, provenance: p });
   }
@@ -17423,7 +17562,7 @@ function buildOverviewSections(graph, incidents) {
       heading: `Nodes with incidents \u2014 ${incidents.length} recorded`,
       facts: top.map(([k, n]) => ({
         text: `${k} \u2014 ${n} incident${n === 1 ? "" : "s"}`,
-        provenance: Provenance26.OBSERVED
+        provenance: Provenance27.OBSERVED
       }))
     });
   }
@@ -17954,14 +18093,14 @@ function getConnectorStatus(id, now = Date.now(), thresholdMs = CONNECTOR_STALE_
 }
 
 // src/connectors/index.ts
-import { NodeType as NodeType33, parseFileId as parseFileId2, Provenance as Provenance27 } from "@neat.is/types";
+import { NodeType as NodeType33, parseFileId as parseFileId2, Provenance as Provenance28 } from "@neat.is/types";
 var NO_ENV = "unknown";
 function staticCallSiteFor(graph, serviceName, targetNodeId) {
   if (!graph.hasNode(targetNodeId)) return void 0;
   const sites = [];
   for (const edgeId of graph.inboundEdges(targetNodeId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.provenance !== Provenance27.EXTRACTED) continue;
+    if (edge.provenance !== Provenance28.EXTRACTED) continue;
     const parsed = parseFileId2(edge.source);
     if (!parsed || parsed.service !== serviceName || !edge.evidence) continue;
     const site = { relPath: edge.evidence.file };
@@ -18003,7 +18142,7 @@ async function runConnectorPoll(connector, ctx, graph, resolveTarget) {
         errorMessage: signal.incident.errorMessage,
         ...signal.incident.attributes ? { attributes: signal.incident.attributes } : {},
         affectedNode: resolved.targetNodeId
-      });
+      }, ctx.project);
       continue;
     }
     if (resolved.ensureInfraNode) {
@@ -21277,6 +21416,7 @@ async function startConnectorPolling(input) {
       registration.connector,
       {
         projectDir: input.projectDir,
+        project: input.project,
         credentials: registration.credentials,
         ...input.errorsPath ? { errorsPath: input.errorsPath } : {}
       },
@@ -21620,6 +21760,7 @@ function registerRoutes(scope, ctx) {
           reg.connector,
           {
             projectDir: proj.scanPath ?? "",
+            project: proj.name,
             credentials: reg.credentials,
             ...incidentsPath ? { errorsPath: incidentsPath } : {}
           },
@@ -21683,6 +21824,39 @@ function registerRoutes(scope, ctx) {
     if (!result) return reply.code(404).send({ error: "no root cause found", id: nodeId });
     return result;
   });
+  scope.get("/graph/incident-card/:nodeId", async (req, reply) => {
+    const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
+    if (!proj) return;
+    const { nodeId } = req.params;
+    if (!proj.graph.hasNode(nodeId)) {
+      return reply.code(404).send({ error: "node not found", id: nodeId });
+    }
+    const epath = errorsPathFor(proj);
+    const incidents = epath ? await readErrorEvents(epath) : [];
+    let errorEvent;
+    if (req.query.errorId) {
+      errorEvent = incidents.find((e) => e.id === req.query.errorId);
+      if (!errorEvent) {
+        return reply.code(404).send({ error: "error event not found", id: req.query.errorId });
+      }
+    } else {
+      const svc = nodeId.replace(/^service:/, "");
+      errorEvent = [...incidents].filter((e) => e.affectedNode === nodeId || e.service === svc).sort((a, b) => (b.timestamp ?? "").localeCompare(a.timestamp ?? ""))[0];
+      if (!errorEvent) {
+        return reply.code(404).send({ error: "no incident found for node", id: nodeId });
+      }
+    }
+    const policyPath = ctx.policyFilePathFor(proj);
+    let policies = [];
+    if (policyPath) {
+      try {
+        policies = await loadPolicyFile(policyPath);
+      } catch {
+        policies = [];
+      }
+    }
+    return buildIncidentCard(proj.graph, errorEvent, incidents, policies);
+  });
   scope.get("/graph/blast-radius/:nodeId", async (req, reply) => {
     const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
@@ -22304,4 +22478,4 @@ export {
   deprovisionConnector,
   buildApi
 };
-//# sourceMappingURL=chunk-KZBFP7L6.js.map
+//# sourceMappingURL=chunk-G4A6FCKG.js.map