@neat.is/core 0.6.3 → 0.6.4

package/dist/neatd.js

@@ -2,11 +2,11 @@
 import {
   reconcileDaemonRecordSync,
   startDaemon
-} from "./chunk-PWIT35Z4.js";
+} from "./chunk-22X2YM5H.js";
 import {
   listProjects,
   registryPath
-} from "./chunk-L64CATKE.js";
+} from "./chunk-UCDXHLCJ.js";
 import {
   BindAuthorityError,
   __require

package/dist/server.cjs

@@ -2038,6 +2038,41 @@ async function writeExtractionErrors(errors, errorsPath) {
   const lines = errors.map((e) => JSON.stringify(e)).join("\n") + "\n";
   await import_node_fs6.promises.appendFile(errorsPath, lines, "utf8");
 }
+function extractionHealthPathFor(errorsPath) {
+  const dir = import_node_path6.default.dirname(errorsPath);
+  const suffix = import_node_path6.default.basename(errorsPath).replace(/^errors/, "").replace(/\.ndjson$/, "");
+  return import_node_path6.default.join(dir, `extraction-health${suffix}.json`);
+}
+var HEALTH_FILE_SAMPLE = 100;
+async function writeExtractionHealth(errors, healthPath, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const byProducer = {};
+  for (const e of errors) byProducer[e.producer] = (byProducer[e.producer] ?? 0) + 1;
+  const coverage = {
+    skippedFiles: errors.length,
+    byProducer,
+    files: errors.slice(0, HEALTH_FILE_SAMPLE).map((e) => e.file),
+    updatedAt: now
+  };
+  await import_node_fs6.promises.mkdir(import_node_path6.default.dirname(healthPath), { recursive: true });
+  await import_node_fs6.promises.writeFile(healthPath, JSON.stringify(coverage), "utf8");
+}
+async function readExtractionHealth(healthPath) {
+  let raw;
+  try {
+    raw = await import_node_fs6.promises.readFile(healthPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  try {
+    const obj = JSON.parse(raw);
+    if (typeof obj?.skippedFiles !== "number" || !obj.byProducer || !Array.isArray(obj.files)) {
+      return void 0;
+    }
+    return obj;
+  } catch {
+    return void 0;
+  }
+}
 var droppedSink = [];
 function noteExtractedDropped(edge) {
   droppedSink.push(edge);
@@ -2989,14 +3024,16 @@ function reconcileObservedRelPath(graph, serviceName, relPath) {
   return best ?? relPath;
 }
 function ensureObservedFileNode(graph, serviceName, serviceNodeId, callSite) {
-  const relPath = reconcileObservedRelPath(graph, serviceName, callSite.relPath);
-  const fileNodeId = (0, import_types5.fileId)(serviceName, relPath);
+  const svcAttrs = graph.hasNode(serviceNodeId) ? graph.getNodeAttributes(serviceNodeId) : void 0;
+  const canonicalService = svcAttrs && svcAttrs.type === import_types5.NodeType.ServiceNode && typeof svcAttrs.name === "string" ? svcAttrs.name : serviceName;
+  const relPath = reconcileObservedRelPath(graph, canonicalService, callSite.relPath);
+  const fileNodeId = (0, import_types5.fileId)(canonicalService, relPath);
   if (!graph.hasNode(fileNodeId)) {
     const language = languageForExt(relPath);
     const node = {
       id: fileNodeId,
       type: import_types5.NodeType.FileNode,
-      service: serviceName,
+      service: canonicalService,
       path: relPath,
       ...language ? { language } : {},
       ...callSite.originalRelPath ? { originalPath: callSite.originalRelPath } : {},
@@ -8914,6 +8951,15 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
       );
     }
   }
+  if (opts.errorsPath) {
+    try {
+      await writeExtractionHealth(errorEntries, extractionHealthPathFor(opts.errorsPath));
+    } catch (err) {
+      console.warn(
+        `[neat] failed to write extraction health sidecar: ${err.message}`
+      );
+    }
+  }
   const droppedEntries = drainDroppedExtracted();
   if (isRejectedLogEnabled() && opts.errorsPath && droppedEntries.length > 0) {
     const rejectedPath = import_node_path45.default.join(import_node_path45.default.dirname(opts.errorsPath), "rejected.ndjson");
@@ -9214,6 +9260,75 @@ function neatHome() {
 function registryPath() {
   return import_node_path48.default.join(neatHome(), "projects.json");
 }
+function daemonsDir() {
+  return import_node_path48.default.join(neatHome(), "daemons");
+}
+function isFiniteInt(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function parseDaemonRecord(raw) {
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (typeof obj !== "object" || obj === null) return void 0;
+  const r = obj;
+  const ports = r.ports;
+  if (typeof r.project !== "string" || typeof r.projectPath !== "string" || !isFiniteInt(r.pid) || r.status !== "running" && r.status !== "stopped" || typeof r.startedAt !== "string" || typeof r.neatVersion !== "string" || !ports || !isFiniteInt(ports.rest) || !isFiniteInt(ports.otlp) || !isFiniteInt(ports.web)) {
+    return void 0;
+  }
+  return {
+    project: r.project,
+    projectPath: r.projectPath,
+    pid: r.pid,
+    status: r.status,
+    ports: { rest: ports.rest, otlp: ports.otlp, web: ports.web },
+    startedAt: r.startedAt,
+    neatVersion: r.neatVersion
+  };
+}
+var defaultDiscoveryProbe = { isPidAlive: isPidAliveDefault };
+async function discoverDaemons(probe = defaultDiscoveryProbe) {
+  const dir = daemonsDir();
+  let names;
+  try {
+    names = await import_node_fs28.promises.readdir(dir);
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  const out = [];
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const file = import_node_path48.default.join(dir, name);
+    let raw;
+    try {
+      raw = await import_node_fs28.promises.readFile(file, "utf8");
+    } catch {
+      continue;
+    }
+    const record = parseDaemonRecord(raw);
+    if (!record) continue;
+    const live = record.status === "running" && probe.isPidAlive(record.pid);
+    out.push({ record, live, source: file });
+  }
+  out.sort((a, b) => a.record.project.localeCompare(b.record.project));
+  return out;
+}
+async function findDaemonByProject(name, probe = defaultDiscoveryProbe) {
+  const discovered = await discoverDaemons(probe);
+  return discovered.find((d) => d.record.project === name);
+}
+function isPidAliveDefault(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
 async function readRegistry() {
   const file = registryPath();
   let raw;
@@ -9491,7 +9606,11 @@ function resolveProject(registry, req, reply, bootstrap, singleProject) {
       void reply.code(503).send({ ready: false, project: name, status: "broken" });
       return null;
     }
-    void reply.code(404).send({ error: "project not found", project: name });
+    void reply.code(404).send({
+      error: "project not found",
+      project: name,
+      hint: "This daemon does not host that project. GET /projects lists what it serves (see hostedHere)."
+    });
     return null;
   }
   return ctx;
@@ -9529,6 +9648,9 @@ function registerRoutes(scope, ctx) {
       const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
       if (!proj) return;
       const uptimeMs = Date.now() - startedAt;
+      const coverage = await readExtractionHealth(
+        extractionHealthPathFor(proj.paths.errorsPath)
+      );
       return {
         ok: true,
         project: proj.name,
@@ -9539,7 +9661,8 @@ function registerRoutes(scope, ctx) {
         uptime: Math.floor(uptimeMs / 1e3),
         nodeCount: proj.graph.order,
         edgeCount: proj.graph.size,
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+        ...coverage ? { coverage } : {}
       };
     });
   }
@@ -10181,12 +10304,17 @@ async function buildApi(opts) {
         // The daemon is serving this project, so it's active unless its
         // bootstrap broke. ('bootstrapping' still reads as active — the project
         // is the one to land on; its graph route answers 503 until ready.)
-        status: phase === "broken" ? "broken" : "active"
+        status: phase === "broken" ? "broken" : "active",
+        hostedHere: true
       };
       return [entry];
     }
     try {
-      return await listProjects();
+      const entries = await listProjects();
+      return entries.map((entry) => ({
+        ...entry,
+        hostedHere: registry.has(entry.name)
+      }));
     } catch (err) {
       return reply.code(500).send({
         error: "failed to read project registry",
@@ -10200,7 +10328,21 @@ async function buildApi(opts) {
       if (!entry) {
         return reply.code(404).send({ error: "project not found", project: req.params.project });
       }
-      return { project: entry };
+      const hostedHere = registry.has(entry.name);
+      if (!hostedHere) {
+        const owner = await findDaemonByProject(entry.name).catch(() => void 0);
+        if (owner) {
+          return {
+            project: { ...entry, hostedHere },
+            servedBy: {
+              path: owner.record.projectPath,
+              restPort: owner.record.ports.rest,
+              live: owner.live
+            }
+          };
+        }
+      }
+      return { project: { ...entry, hostedHere } };
     } catch (err) {
       return reply.code(500).send({
         error: "failed to read project registry",