@neat.is/core 0.3.4 → 0.3.6

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   routeSpanToProject,
   startDaemon
-} from "./chunk-T3A2GK3X.js";
+} from "./chunk-YHQYHFI3.js";
 import {
   ProjectNameCollisionError,
   addProject,
@@ -37,7 +37,7 @@ import {
   thresholdForEdgeType,
   touchLastSeen,
   writeAtomically
-} from "./chunk-33ZZ2ZID.js";
+} from "./chunk-ZU2RQRCN.js";
 import {
   startOtelGrpcReceiver
 } from "./chunk-G3PDTGOW.js";

package/dist/neatd.cjs

@@ -371,6 +371,7 @@ var init_otel = __esm({
 init_cjs_shims();
 var import_node_fs22 = require("fs");
 var import_node_path38 = __toESM(require("path"), 1);
+var import_node_module = require("module");
 
 // src/daemon.ts
 init_cjs_shims();
@@ -749,11 +750,16 @@ init_cjs_shims();
 var import_types = require("@neat.is/types");
 var ROOT_CAUSE_MAX_DEPTH = 5;
 var BLAST_RADIUS_DEFAULT_DEPTH = 10;
+function isFrontierNode(graph, nodeId) {
+  if (!graph.hasNode(nodeId)) return false;
+  const attrs = graph.getNodeAttributes(nodeId);
+  return attrs.type === import_types.NodeType.FrontierNode;
+}
 function bestEdgeBySource(graph, edgeIds) {
   const best = /* @__PURE__ */ new Map();
   for (const id of edgeIds) {
     const e = graph.getEdgeAttributes(id);
-    if (e.provenance === import_types.Provenance.FRONTIER) continue;
+    if (isFrontierNode(graph, e.source)) continue;
     const cur = best.get(e.source);
     if (!cur || import_types.PROV_RANK[e.provenance] > import_types.PROV_RANK[cur.provenance]) {
       best.set(e.source, e);
@@ -765,7 +771,7 @@ function bestEdgeByTarget(graph, edgeIds) {
   const best = /* @__PURE__ */ new Map();
   for (const id of edgeIds) {
     const e = graph.getEdgeAttributes(id);
-    if (e.provenance === import_types.Provenance.FRONTIER) continue;
+    if (isFrontierNode(graph, e.target)) continue;
     const cur = best.get(e.target);
     if (!cur || import_types.PROV_RANK[e.provenance] > import_types.PROV_RANK[cur.provenance]) {
       best.set(e.target, e);
@@ -777,8 +783,7 @@ var PROVENANCE_CEILING = {
   OBSERVED: 1,
   INFERRED: 0.7,
   EXTRACTED: 0.5,
-  STALE: 0.3,
-  FRONTIER: 0.3
+  STALE: 0.3
 };
 function volumeWeight(spanCount) {
   if (!spanCount || spanCount <= 0) return 0.5;
@@ -1062,8 +1067,8 @@ var evaluateStructural = ({
     for (const edgeId of graph.outboundEdges(id)) {
       const e = graph.getEdgeAttributes(edgeId);
       if (e.type !== rule.edgeType) continue;
-      if (e.provenance === import_types2.Provenance.FRONTIER) continue;
       const target = graph.getNodeAttributes(e.target);
+      if (target.type === import_types2.NodeType.FrontierNode) continue;
       if (target.type === rule.toNodeType) {
         satisfied = true;
         break;
@@ -1182,8 +1187,8 @@ var evaluateCompatibility = ({
       for (const edgeId of graph.outboundEdges(svcId)) {
         const e = graph.getEdgeAttributes(edgeId);
         if (e.type !== import_types2.EdgeType.CONNECTS_TO) continue;
-        if (e.provenance === import_types2.Provenance.FRONTIER) continue;
         const dbAttrs = graph.getNodeAttributes(e.target);
+        if (dbAttrs.type === import_types2.NodeType.FrontierNode) continue;
         if (dbAttrs.type !== import_types2.NodeType.DatabaseNode) continue;
         const db = dbAttrs;
         for (const pair of compatPairs()) {
@@ -1478,31 +1483,6 @@ function ensureFrontierNode(graph, host, ts) {
   graph.addNode(id, node);
   return id;
 }
-function upsertFrontierEdge(graph, type, source, target, ts) {
-  const id = (0, import_types3.frontierEdgeId)(source, target, type);
-  if (graph.hasEdge(id)) {
-    const existing = graph.getEdgeAttributes(id);
-    const updated = {
-      ...existing,
-      provenance: import_types3.Provenance.FRONTIER,
-      lastObserved: ts,
-      callCount: (existing.callCount ?? 0) + 1
-    };
-    graph.replaceEdgeAttributes(id, updated);
-    return;
-  }
-  const edge = {
-    id,
-    source,
-    target,
-    type,
-    provenance: import_types3.Provenance.FRONTIER,
-    confidence: 1,
-    lastObserved: ts,
-    callCount: 1
-  };
-  graph.addEdgeWithKey(id, source, target, edge);
-}
 function upsertObservedEdge(graph, type, source, target, ts, isError = false) {
   if (!graph.hasNode(source) || !graph.hasNode(target)) return null;
   const id = makeObservedEdgeId(type, source, target);
@@ -1588,18 +1568,28 @@ async function appendErrorEvent(ctx, ev) {
   await import_node_fs3.promises.mkdir(import_node_path3.default.dirname(ctx.errorsPath), { recursive: true });
   await import_node_fs3.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
 }
+function sanitizeAttributes(attrs) {
+  const out = {};
+  for (const [k, v] of Object.entries(attrs)) {
+    if (typeof v === "bigint") out[k] = v.toString();
+    else out[k] = v;
+  }
+  return out;
+}
 function buildErrorEventForReceiver(span) {
   if (span.statusCode !== 2) return null;
   const ts = span.startTimeIso ?? (/* @__PURE__ */ new Date()).toISOString();
+  const attrs = sanitizeAttributes(span.attributes);
   return {
     id: `${span.traceId}:${span.spanId}`,
     timestamp: ts,
     service: span.service,
     traceId: span.traceId,
     spanId: span.spanId,
-    errorMessage: span.exception?.message ?? span.errorMessage ?? span.name ?? "unknown error",
+    errorMessage: span.exception?.message ?? "unknown error",
     ...span.exception?.type ? { exceptionType: span.exception.type } : {},
     ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
+    ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
     affectedNode: (0, import_types3.serviceId)(span.service)
   };
 }
@@ -1650,11 +1640,16 @@ async function handleSpan(ctx, span) {
         affectedNode = targetId;
         resolvedViaAddress = true;
       } else if (!targetId) {
-        const frontierId2 = ensureFrontierNode(ctx.graph, host, ts);
-        if (ctx.graph.hasNode(sourceId)) {
-          upsertFrontierEdge(ctx.graph, import_types3.EdgeType.CALLS, sourceId, frontierId2, ts);
-        }
-        affectedNode = frontierId2;
+        const frontierNodeId = ensureFrontierNode(ctx.graph, host, ts);
+        upsertObservedEdge(
+          ctx.graph,
+          import_types3.EdgeType.CALLS,
+          sourceId,
+          frontierNodeId,
+          ts,
+          isError
+        );
+        affectedNode = frontierNodeId;
         resolvedViaAddress = true;
       }
     }
@@ -1676,15 +1671,17 @@ async function handleSpan(ctx, span) {
   if (span.statusCode === 2) {
     stitchTrace(ctx.graph, sourceId, ts);
     if (ctx.writeErrorEventInline !== false) {
+      const attrs = sanitizeAttributes(span.attributes);
       const ev = {
         id: `${span.traceId}:${span.spanId}`,
         timestamp: ts,
         service: span.service,
         traceId: span.traceId,
         spanId: span.spanId,
-        errorMessage: span.exception?.message ?? span.errorMessage ?? span.name ?? "unknown error",
+        errorMessage: span.exception?.message ?? "unknown error",
         ...span.exception?.type ? { exceptionType: span.exception.type } : {},
         ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
+        ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
         affectedNode
       };
       await appendErrorEvent(ctx, ev);
@@ -1740,8 +1737,7 @@ function rewireFrontierEdges(graph, frontierId2, serviceId3) {
 }
 function rebuildEdge(graph, edge, newSource, newTarget, oldEdgeId) {
   graph.dropEdge(oldEdgeId);
-  const promotedProvenance = edge.provenance === import_types3.Provenance.FRONTIER ? import_types3.Provenance.OBSERVED : edge.provenance;
-  const newId = promotedProvenance === import_types3.Provenance.OBSERVED ? (0, import_types3.observedEdgeId)(newSource, newTarget, edge.type) : promotedProvenance === import_types3.Provenance.INFERRED ? (0, import_types3.inferredEdgeId)(newSource, newTarget, edge.type) : promotedProvenance === import_types3.Provenance.EXTRACTED ? (0, import_types3.extractedEdgeId)(newSource, newTarget, edge.type) : (0, import_types3.frontierEdgeId)(newSource, newTarget, edge.type);
+  const newId = edge.provenance === import_types3.Provenance.OBSERVED ? (0, import_types3.observedEdgeId)(newSource, newTarget, edge.type) : edge.provenance === import_types3.Provenance.INFERRED ? (0, import_types3.inferredEdgeId)(newSource, newTarget, edge.type) : (0, import_types3.extractedEdgeId)(newSource, newTarget, edge.type);
   if (graph.hasEdge(newId)) {
     const existing = graph.getEdgeAttributes(newId);
     const merged = {
@@ -1756,8 +1752,7 @@ function rebuildEdge(graph, edge, newSource, newTarget, oldEdgeId) {
     ...edge,
     id: newId,
     source: newSource,
-    target: newTarget,
-    provenance: promotedProvenance
+    target: newTarget
   };
   graph.addEdgeWithKey(newId, newSource, newTarget, rebuilt);
 }
@@ -3981,7 +3976,8 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
 init_cjs_shims();
 var import_node_fs18 = require("fs");
 var import_node_path31 = __toESM(require("path"), 1);
-var SCHEMA_VERSION = 2;
+var import_types19 = require("@neat.is/types");
+var SCHEMA_VERSION = 3;
 function migrateV1ToV2(payload) {
   const nodes = payload.graph.nodes;
   if (Array.isArray(nodes)) {
@@ -3993,6 +3989,25 @@ function migrateV1ToV2(payload) {
   }
   return { ...payload, schemaVersion: 2 };
 }
+function migrateV2ToV3(payload) {
+  const edges = payload.graph.edges;
+  if (Array.isArray(edges)) {
+    for (const edge of edges) {
+      const attrs = edge.attributes;
+      if (!attrs || attrs.provenance !== "FRONTIER") continue;
+      attrs.provenance = import_types19.Provenance.OBSERVED;
+      const type = typeof attrs.type === "string" ? attrs.type : void 0;
+      const source = typeof attrs.source === "string" ? attrs.source : void 0;
+      const target = typeof attrs.target === "string" ? attrs.target : void 0;
+      if (type && source && target) {
+        const newId = (0, import_types19.observedEdgeId)(source, target, type);
+        attrs.id = newId;
+        if (edge.key) edge.key = newId;
+      }
+    }
+  }
+  return { ...payload, schemaVersion: 3 };
+}
 async function ensureDir(filePath) {
   await import_node_fs18.promises.mkdir(import_node_path31.default.dirname(filePath), { recursive: true });
 }
@@ -4019,6 +4034,9 @@ async function loadGraphFromDisk(graph, outPath) {
   if (payload.schemaVersion === 1) {
     payload = migrateV1ToV2(payload);
   }
+  if (payload.schemaVersion === 2) {
+    payload = migrateV2ToV3(payload);
+  }
   if (payload.schemaVersion !== SCHEMA_VERSION) {
     throw new Error(
       `persist: unsupported snapshot schemaVersion ${payload.schemaVersion} (expected ${SCHEMA_VERSION})`
@@ -4117,11 +4135,11 @@ var Projects = class {
 init_cjs_shims();
 var import_fastify = __toESM(require("fastify"), 1);
 var import_cors = __toESM(require("@fastify/cors"), 1);
-var import_types21 = require("@neat.is/types");
+var import_types22 = require("@neat.is/types");
 
 // src/divergences.ts
 init_cjs_shims();
-var import_types19 = require("@neat.is/types");
+var import_types20 = require("@neat.is/types");
 function bucketKey(source, target, type) {
   return `${type}|${source}|${target}`;
 }
@@ -4129,25 +4147,22 @@ function bucketEdges(graph) {
   const buckets = /* @__PURE__ */ new Map();
   graph.forEachEdge((id, attrs) => {
     const e = attrs;
-    const parsed = (0, import_types19.parseEdgeId)(id);
+    const parsed = (0, import_types20.parseEdgeId)(id);
     const provenance = parsed?.provenance ?? e.provenance;
     const key = bucketKey(e.source, e.target, e.type);
     const cur = buckets.get(key) ?? { source: e.source, target: e.target, type: e.type };
     switch (provenance) {
-      case import_types19.Provenance.EXTRACTED:
+      case import_types20.Provenance.EXTRACTED:
         cur.extracted = e;
         break;
-      case import_types19.Provenance.OBSERVED:
+      case import_types20.Provenance.OBSERVED:
         cur.observed = e;
         break;
-      case import_types19.Provenance.INFERRED:
+      case import_types20.Provenance.INFERRED:
         cur.inferred = e;
         break;
-      case import_types19.Provenance.FRONTIER:
-        cur.frontier = e;
-        break;
       default:
-        if (e.provenance === import_types19.Provenance.STALE) cur.stale = e;
+        if (e.provenance === import_types20.Provenance.STALE) cur.stale = e;
     }
     buckets.set(key, cur);
   });
@@ -4156,7 +4171,7 @@ function bucketEdges(graph) {
 function nodeIsFrontier(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === import_types19.NodeType.FrontierNode;
+  return attrs.type === import_types20.NodeType.FrontierNode;
 }
 function clampConfidence(n) {
   if (!Number.isFinite(n)) return 0;
@@ -4217,7 +4232,7 @@ function declaredHostFor(svc) {
 function hasExtractedConfiguredBy(graph, svcId) {
   for (const edgeId of graph.outboundEdges(svcId)) {
     const e = graph.getEdgeAttributes(edgeId);
-    if (e.type === import_types19.EdgeType.CONFIGURED_BY && e.provenance === import_types19.Provenance.EXTRACTED) {
+    if (e.type === import_types20.EdgeType.CONFIGURED_BY && e.provenance === import_types20.Provenance.EXTRACTED) {
       return true;
     }
   }
@@ -4230,10 +4245,10 @@ function detectHostMismatch(graph, svcId, svc) {
   const out = [];
   for (const edgeId of graph.outboundEdges(svcId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types19.EdgeType.CONNECTS_TO) continue;
-    if (edge.provenance !== import_types19.Provenance.OBSERVED) continue;
+    if (edge.type !== import_types20.EdgeType.CONNECTS_TO) continue;
+    if (edge.provenance !== import_types20.Provenance.OBSERVED) continue;
     const target = graph.getNodeAttributes(edge.target);
-    if (target.type !== import_types19.NodeType.DatabaseNode) continue;
+    if (target.type !== import_types20.NodeType.DatabaseNode) continue;
     const observedHost = target.host?.trim();
     if (!observedHost) continue;
     if (observedHost === declaredHost) continue;
@@ -4255,10 +4270,10 @@ function detectCompatDivergences(graph, svcId, svc) {
   const deps = svc.dependencies ?? {};
   for (const edgeId of graph.outboundEdges(svcId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types19.EdgeType.CONNECTS_TO) continue;
-    if (edge.provenance !== import_types19.Provenance.OBSERVED) continue;
+    if (edge.type !== import_types20.EdgeType.CONNECTS_TO) continue;
+    if (edge.provenance !== import_types20.Provenance.OBSERVED) continue;
     const target = graph.getNodeAttributes(edge.target);
-    if (target.type !== import_types19.NodeType.DatabaseNode) continue;
+    if (target.type !== import_types20.NodeType.DatabaseNode) continue;
     for (const pair of compatPairs()) {
       if (pair.engine !== target.engine) continue;
       const declared = deps[pair.driver];
@@ -4319,7 +4334,7 @@ function computeDivergences(graph, opts = {}) {
   }
   graph.forEachNode((nodeId, attrs) => {
     const n = attrs;
-    if (n.type !== import_types19.NodeType.ServiceNode) return;
+    if (n.type !== import_types20.NodeType.ServiceNode) return;
     const svc = n;
     for (const d of detectHostMismatch(graph, nodeId, svc)) all.push(d);
     for (const d of detectCompatDivergences(graph, nodeId, svc)) all.push(d);
@@ -4352,7 +4367,7 @@ function computeDivergences(graph, opts = {}) {
     if (a.source !== b.source) return a.source.localeCompare(b.source);
     return a.target.localeCompare(b.target);
   });
-  return import_types19.DivergenceResultSchema.parse({
+  return import_types20.DivergenceResultSchema.parse({
     divergences: filtered,
     totalAffected: filtered.length,
     computedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -4441,7 +4456,7 @@ init_cjs_shims();
 var import_node_fs20 = require("fs");
 var import_node_os2 = __toESM(require("os"), 1);
 var import_node_path33 = __toESM(require("path"), 1);
-var import_types20 = require("@neat.is/types");
+var import_types21 = require("@neat.is/types");
 var LOCK_TIMEOUT_MS = 5e3;
 var LOCK_RETRY_MS = 50;
 function neatHome() {
@@ -4512,10 +4527,10 @@ async function readRegistry() {
     throw err;
   }
   const parsed = JSON.parse(raw);
-  return import_types20.RegistryFileSchema.parse(parsed);
+  return import_types21.RegistryFileSchema.parse(parsed);
 }
 async function writeRegistry(reg) {
-  const validated = import_types20.RegistryFileSchema.parse(reg);
+  const validated = import_types21.RegistryFileSchema.parse(reg);
   await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + "\n");
 }
 async function getProject(name) {
@@ -4725,11 +4740,11 @@ function registerRoutes(scope, ctx) {
       const candidates = req2.query.type.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
       const parsed = [];
       for (const c of candidates) {
-        const r = import_types21.DivergenceTypeSchema.safeParse(c);
+        const r = import_types22.DivergenceTypeSchema.safeParse(c);
         if (!r.success) {
           return reply.code(400).send({
             error: `unknown divergence type "${c}"`,
-            allowed: import_types21.DivergenceTypeSchema.options
+            allowed: import_types22.DivergenceTypeSchema.options
           });
         }
         parsed.push(r.data);
@@ -4913,7 +4928,7 @@ function registerRoutes(scope, ctx) {
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
     if (req2.query.severity) {
-      const sev = import_types21.PolicySeveritySchema.safeParse(req2.query.severity);
+      const sev = import_types22.PolicySeveritySchema.safeParse(req2.query.severity);
       if (!sev.success) {
         return reply.code(400).send({
           error: "invalid severity",
@@ -4930,7 +4945,7 @@ function registerRoutes(scope, ctx) {
   scope.post("/policies/check", async (req2, reply) => {
     const proj = resolveProject(registry, req2, reply);
     if (!proj) return;
-    const parsed = import_types21.PoliciesCheckBodySchema.safeParse(req2.body ?? {});
+    const parsed = import_types22.PoliciesCheckBodySchema.safeParse(req2.body ?? {});
     if (!parsed.success) {
       return reply.code(400).send({
         error: "invalid /policies/check body",
@@ -5375,7 +5390,83 @@ async function spawnWebUI(restPort) {
   return { child, port, stop };
 }
 
+// src/version-skew.ts
+init_cjs_shims();
+var import_promises = require("timers/promises");
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/neat.is/latest";
+var DEFAULT_TIMEOUT_MS = 2e3;
+async function fetchRegistryVersion(url, timeoutMs, fetchImpl) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const timer = (0, import_promises.setTimeout)(timeoutMs).then(() => {
+    timedOut = true;
+    controller.abort();
+  });
+  try {
+    const res = await Promise.race([
+      fetchImpl(url, { signal: controller.signal, headers: { accept: "application/json" } }),
+      timer.then(() => null)
+    ]);
+    if (timedOut || !res) return null;
+    if (!res.ok) return null;
+    const body = await res.json();
+    if (typeof body.version !== "string" || body.version.length === 0) return null;
+    return body.version;
+  } catch {
+    return null;
+  } finally {
+    if (!timedOut) controller.abort();
+  }
+}
+function isLocalBehind(local, remote) {
+  if (local === remote) return false;
+  const parse10 = (v) => {
+    const core = v.split(/[-+]/)[0] ?? v;
+    return core.split(".").map((s) => {
+      const n = Number.parseInt(s, 10);
+      return Number.isFinite(n) ? n : 0;
+    });
+  };
+  const a = parse10(local);
+  const b = parse10(remote);
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    if (av < bv) return true;
+    if (av > bv) return false;
+  }
+  return false;
+}
+async function checkVersionSkew(opts) {
+  const url = opts.registryUrl ?? NPM_REGISTRY_URL;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const warn = opts.warn ?? ((m) => console.warn(m));
+  const remote = await fetchRegistryVersion(url, timeoutMs, fetchImpl);
+  if (!remote) return { remoteVersion: null, skewed: false, warned: false };
+  if (!isLocalBehind(opts.localVersion, remote)) {
+    return { remoteVersion: remote, skewed: false, warned: false };
+  }
+  warn(
+    `[neatd] running neat.is@${opts.localVersion} but neat.is@${remote} is on npm \u2014 run \`npm install -g neat.is@latest\` to update`
+  );
+  return { remoteVersion: remote, skewed: true, warned: true };
+}
+
 // src/neatd.ts
+function localVersion() {
+  if (process.env.NEAT_LOCAL_VERSION && process.env.NEAT_LOCAL_VERSION.length > 0) {
+    return process.env.NEAT_LOCAL_VERSION;
+  }
+  try {
+    const req2 = (0, import_node_module.createRequire)(importMetaUrl);
+    const pkg = req2("../package.json");
+    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
 function neatHome2() {
   if (process.env.NEAT_HOME && process.env.NEAT_HOME.length > 0) {
     return import_node_path38.default.resolve(process.env.NEAT_HOME);
@@ -5405,6 +5496,10 @@ async function cmdStart() {
   console.log(`neatd: registry at ${registryPath()}`);
   if (handle.restAddress) console.log(`neatd: REST  \u2192 ${handle.restAddress}`);
   if (handle.otlpAddress) console.log(`neatd: OTLP  \u2192 ${handle.otlpAddress}`);
+  if (process.env.NEAT_DISABLE_VERSION_CHECK !== "1") {
+    void checkVersionSkew({ localVersion: localVersion() }).catch(() => {
+    });
+  }
   const skipWeb = process.env.NEAT_WEB_DISABLED === "1";
   let web = null;
   if (!skipWeb) {