@neat.is/core 0.2.10 → 0.3.1

package/dist/index.cjs

@@ -1653,6 +1653,29 @@ 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 buildErrorEventForReceiver(span) {
+  if (span.statusCode !== 2) return null;
+  const ts = span.startTimeIso ?? (/* @__PURE__ */ new Date()).toISOString();
+  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",
+    ...span.exception?.type ? { exceptionType: span.exception.type } : {},
+    ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
+    affectedNode: (0, import_types3.serviceId)(span.service)
+  };
+}
+function makeErrorSpanWriter(errorsPath) {
+  return async (span) => {
+    const ev = buildErrorEventForReceiver(span);
+    if (!ev) return;
+    await import_node_fs3.promises.mkdir(import_node_path3.default.dirname(errorsPath), { recursive: true });
+    await import_node_fs3.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  };
+}
 async function handleSpan(ctx, span) {
   const ts = span.startTimeIso ?? nowIso(ctx);
   const nowMs = ctx.now ? ctx.now() : Date.now();
@@ -4516,9 +4539,15 @@ function registerRoutes(scope, ctx) {
   scope.get("/health", async (req, reply) => {
     const proj = resolveProject(registry, req, reply);
     if (!proj) return;
+    const uptimeMs = Date.now() - startedAt;
     return {
-      uptime: Math.floor((Date.now() - startedAt) / 1e3),
+      ok: true,
       project: proj.name,
+      uptimeMs,
+      // Legacy fields kept additively. The web shell's StatusBar reads
+      // nodeCount / edgeCount; ADR-061's HealthResponseSchema validates
+      // the canonical triple and lets the extras pass through.
+      uptime: Math.floor(uptimeMs / 1e3),
       nodeCount: proj.graph.order,
       edgeCount: proj.graph.size,
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
@@ -4538,7 +4567,7 @@ function registerRoutes(scope, ctx) {
       if (!proj.graph.hasNode(id)) {
         return reply.code(404).send({ error: "node not found", id });
       }
-      return proj.graph.getNodeAttributes(id);
+      return { node: proj.graph.getNodeAttributes(id) };
     }
   );
   scope.get(
@@ -4555,12 +4584,12 @@ function registerRoutes(scope, ctx) {
       return { inbound, outbound };
     }
   );
-  scope.get("/graph/node/:id/dependencies", async (req, reply) => {
+  scope.get("/graph/dependencies/:nodeId", async (req, reply) => {
     const proj = resolveProject(registry, req, reply);
     if (!proj) return;
-    const { id } = req.params;
-    if (!proj.graph.hasNode(id)) {
-      return reply.code(404).send({ error: "node not found", id });
+    const { nodeId } = req.params;
+    if (!proj.graph.hasNode(nodeId)) {
+      return reply.code(404).send({ error: "node not found", id: nodeId });
     }
     const depth = req.query.depth ? Number(req.query.depth) : TRANSITIVE_DEPENDENCIES_DEFAULT_DEPTH;
     if (!Number.isFinite(depth) || depth < 1 || depth > TRANSITIVE_DEPENDENCIES_MAX_DEPTH) {
@@ -4568,7 +4597,7 @@ function registerRoutes(scope, ctx) {
         error: `depth must be an integer in [1, ${TRANSITIVE_DEPENDENCIES_MAX_DEPTH}]`
       });
     }
-    return getTransitiveDependencies(proj.graph, id, depth);
+    return getTransitiveDependencies(proj.graph, nodeId, depth);
   });
   scope.get("/graph/divergences", async (req, reply) => {
     const proj = resolveProject(registry, req, reply);
@@ -4609,19 +4638,26 @@ function registerRoutes(scope, ctx) {
     const proj = resolveProject(registry, req, reply);
     if (!proj) return;
     const epath = errorsPathFor(proj);
-    if (!epath) return [];
-    return readErrorEvents(epath);
+    if (!epath) return { count: 0, total: 0, events: [] };
+    const events = await readErrorEvents(epath);
+    const total = events.length;
+    const limit = req.query.limit ? Number(req.query.limit) : 50;
+    const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.min(limit, 200) : 50;
+    const sliced = events.slice(0, safeLimit);
+    return { count: sliced.length, total, events: sliced };
   });
-  scope.get("/incidents/stale", async (req, reply) => {
+  scope.get("/stale-events", async (req, reply) => {
     const proj = resolveProject(registry, req, reply);
     if (!proj) return;
     const spath = staleEventsPathFor(proj);
-    if (!spath) return [];
+    if (!spath) return { count: 0, total: 0, events: [] };
     const events = await readStaleEvents(spath);
     const filtered = req.query.edgeType ? events.filter((e) => e.edgeType === req.query.edgeType) : events;
     const ordered = [...filtered].reverse();
+    const total = ordered.length;
     const limit = req.query.limit ? Number(req.query.limit) : 50;
-    return ordered.slice(0, Number.isFinite(limit) && limit > 0 ? limit : 50);
+    const sliced = ordered.slice(0, Number.isFinite(limit) && limit > 0 ? limit : 50);
+    return { count: sliced.length, total, events: sliced };
   });
   scope.get(
     "/incidents/:nodeId",
@@ -4633,14 +4669,15 @@ function registerRoutes(scope, ctx) {
         return reply.code(404).send({ error: "node not found", id: nodeId });
       }
       const epath = errorsPathFor(proj);
-      if (!epath) return [];
+      if (!epath) return { count: 0, total: 0, events: [] };
       const events = await readErrorEvents(epath);
-      return events.filter(
+      const filtered = events.filter(
         (e) => e.affectedNode === nodeId || e.service === nodeId.replace(/^service:/, "")
       );
+      return { count: filtered.length, total: filtered.length, events: filtered };
     }
   );
-  scope.get("/traverse/root-cause/:nodeId", async (req, reply) => {
+  scope.get("/graph/root-cause/:nodeId", async (req, reply) => {
     const proj = resolveProject(registry, req, reply);
     if (!proj) return;
     const { nodeId } = req.params;
@@ -4660,7 +4697,7 @@ function registerRoutes(scope, ctx) {
     if (!result) return reply.code(404).send({ error: "no root cause found", id: nodeId });
     return result;
   });
-  scope.get("/traverse/blast-radius/:nodeId", async (req, reply) => {
+  scope.get("/graph/blast-radius/:nodeId", async (req, reply) => {
     const proj = resolveProject(registry, req, reply);
     if (!proj) return;
     const { nodeId } = req.params;
@@ -4770,7 +4807,7 @@ function registerRoutes(scope, ctx) {
     if (req.query.policyId) {
       violations = violations.filter((v) => v.policyId === req.query.policyId);
     }
-    return violations;
+    return { violations };
   });
   scope.post("/policies/check", async (req, reply) => {
     const proj = resolveProject(registry, req, reply);
@@ -4849,6 +4886,20 @@ async function buildApi(opts) {
       });
     }
   });
+  app.get("/projects/:project", async (req, reply) => {
+    try {
+      const entry = await getProject(req.params.project);
+      if (!entry) {
+        return reply.code(404).send({ error: "project not found", project: req.params.project });
+      }
+      return { project: entry };
+    } catch (err) {
+      return reply.code(500).send({
+        error: "failed to read project registry",
+        details: err.message
+      });
+    }
+  });
   registerRoutes(app, routeCtx);
   await app.register(
     async (scope) => {
@@ -4867,6 +4918,7 @@ init_otel_grpc();
 init_cjs_shims();
 var import_node_fs19 = require("fs");
 var import_node_path33 = __toESM(require("path"), 1);
+init_otel();
 function neatHomeFor(opts) {
   if (opts.neatHome && opts.neatHome.length > 0) return import_node_path33.default.resolve(opts.neatHome);
   const env = process.env.NEAT_HOME;
@@ -4885,6 +4937,7 @@ function routeSpanToProject(serviceName, projects) {
   return DEFAULT_PROJECT;
 }
 async function bootstrapProject(entry) {
+  const paths = pathsForProject(entry.name, import_node_path33.default.join(entry.path, "neat-out"));
   try {
     const stat = await import_node_fs19.promises.stat(entry.path);
     if (!stat.isDirectory()) {
@@ -4899,6 +4952,7 @@ async function bootstrapProject(entry) {
       // output; nothing routes to it because it's not 'active'.
       graph: getGraph(`__broken__:${entry.name}`),
       outPath: "",
+      paths,
       stopPersist: () => {
       },
       status: "broken",
@@ -4907,10 +4961,7 @@ async function bootstrapProject(entry) {
   }
   resetGraph(entry.name);
   const graph = getGraph(entry.name);
-  const outPath = pathsForProject(
-    entry.name,
-    import_node_path33.default.join(entry.path, "neat-out")
-  ).snapshotPath;
+  const outPath = paths.snapshotPath;
   await loadGraphFromDisk(graph, outPath);
   await extractFromDirectory(graph, entry.path);
   const stopPersist = startPersistLoop(graph, outPath);
@@ -4920,10 +4971,35 @@ async function bootstrapProject(entry) {
     entry,
     graph,
     outPath,
+    paths,
     stopPersist,
     status: "active"
   };
 }
+function resolveRestPort(opts) {
+  if (typeof opts.restPort === "number") return opts.restPort;
+  const env = process.env.PORT;
+  if (env && env.length > 0) {
+    const n = Number.parseInt(env, 10);
+    if (Number.isFinite(n)) return n;
+  }
+  return 8080;
+}
+function resolveOtlpPort(opts) {
+  if (typeof opts.otlpPort === "number") return opts.otlpPort;
+  const env = process.env.OTEL_PORT;
+  if (env && env.length > 0) {
+    const n = Number.parseInt(env, 10);
+    if (Number.isFinite(n)) return n;
+  }
+  return 4318;
+}
+function resolveHost(opts) {
+  if (opts.host && opts.host.length > 0) return opts.host;
+  const env = process.env.HOST;
+  if (env && env.length > 0) return env;
+  return "0.0.0.0";
+}
 async function startDaemon(opts = {}) {
   const home = neatHomeFor(opts);
   const regPath = registryPath();
@@ -4938,6 +5014,15 @@ async function startDaemon(opts = {}) {
   await writeAtomically(pidPath, `${process.pid}
 `);
   const slots = /* @__PURE__ */ new Map();
+  const registry = new Projects();
+  function upsertRegistryFromSlot(slot) {
+    if (slot.status !== "active") return;
+    registry.set(slot.entry.name, {
+      scanPath: slot.entry.path,
+      paths: slot.paths,
+      graph: slot.graph
+    });
+  }
   async function loadAll() {
     const projects = await listProjects();
     const seen = /* @__PURE__ */ new Set();
@@ -4947,6 +5032,7 @@ async function startDaemon(opts = {}) {
       try {
         const slot = await bootstrapProject(entry);
         slots.set(entry.name, slot);
+        upsertRegistryFromSlot(slot);
         if (slot.status === "broken") {
           console.warn(`neatd: project "${entry.name}" broken \u2014 ${slot.errorReason}`);
         } else {
@@ -4971,6 +5057,80 @@ async function startDaemon(opts = {}) {
     }
   }
   await loadAll();
+  const bind = opts.bindListeners !== false;
+  let restApp = null;
+  let otlpApp = null;
+  let restAddress = "";
+  let otlpAddress = "";
+  if (bind) {
+    const host = resolveHost(opts);
+    const restPort = resolveRestPort(opts);
+    const otlpPort = resolveOtlpPort(opts);
+    try {
+      restApp = await buildApi({ projects: registry });
+      restAddress = await restApp.listen({ port: restPort, host });
+      console.log(`neatd: REST listening on ${restAddress}`);
+    } catch (err) {
+      for (const slot of slots.values()) {
+        try {
+          slot.stopPersist();
+        } catch {
+        }
+      }
+      if (restApp) await restApp.close().catch(() => {
+      });
+      await import_node_fs19.promises.unlink(pidPath).catch(() => {
+      });
+      throw new Error(
+        `neatd: failed to bind REST on port ${restPort} \u2014 ${err.message}`
+      );
+    }
+    try {
+      otlpApp = await buildOtelReceiver({
+        onSpan: async (span) => {
+          const liveEntries = await listProjects().catch(() => []);
+          const target = routeSpanToProject(span.service, liveEntries);
+          const slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
+          if (!slot || slot.status !== "active") return;
+          await handleSpan(
+            {
+              graph: slot.graph,
+              errorsPath: slot.paths.errorsPath,
+              project: slot.entry.name,
+              // Receiver already wrote the error event synchronously below.
+              writeErrorEventInline: false
+            },
+            span
+          );
+        },
+        onErrorSpanSync: async (span) => {
+          const liveEntries = await listProjects().catch(() => []);
+          const target = routeSpanToProject(span.service, liveEntries);
+          const slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
+          if (!slot || slot.status !== "active") return;
+          await makeErrorSpanWriter(slot.paths.errorsPath)(span);
+        }
+      });
+      otlpAddress = await otlpApp.listen({ port: otlpPort, host });
+      console.log(`neatd: OTLP listening on ${otlpAddress}/v1/traces`);
+    } catch (err) {
+      for (const slot of slots.values()) {
+        try {
+          slot.stopPersist();
+        } catch {
+        }
+      }
+      if (restApp) await restApp.close().catch(() => {
+      });
+      if (otlpApp) await otlpApp.close().catch(() => {
+      });
+      await import_node_fs19.promises.unlink(pidPath).catch(() => {
+      });
+      throw new Error(
+        `neatd: failed to bind OTLP on port ${otlpPort} \u2014 ${err.message}`
+      );
+    }
+  }
   let reloading = null;
   const reload = async () => {
     if (reloading) return reloading;
@@ -4994,6 +5154,10 @@ async function startDaemon(opts = {}) {
     if (stopped) return;
     stopped = true;
     process.off("SIGHUP", sighupHandler);
+    if (otlpApp) await otlpApp.close().catch(() => {
+    });
+    if (restApp) await restApp.close().catch(() => {
+    });
     for (const slot of slots.values()) {
       try {
         slot.stopPersist();
@@ -5003,7 +5167,7 @@ async function startDaemon(opts = {}) {
     await import_node_fs19.promises.unlink(pidPath).catch(() => {
     });
   };
-  return { slots, reload, stop, pidPath };
+  return { slots, reload, stop, pidPath, restAddress, otlpAddress };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {