@neat.is/core 0.6.3 → 0.6.4

package/dist/cli.cjs

@@ -2329,6 +2329,41 @@ async function writeExtractionErrors(errors, errorsPath) {
   const lines = errors.map((e) => JSON.stringify(e)).join("\n") + "\n";
   await import_node_fs5.promises.appendFile(errorsPath, lines, "utf8");
 }
+function extractionHealthPathFor(errorsPath) {
+  const dir = import_node_path5.default.dirname(errorsPath);
+  const suffix = import_node_path5.default.basename(errorsPath).replace(/^errors/, "").replace(/\.ndjson$/, "");
+  return import_node_path5.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_fs5.promises.mkdir(import_node_path5.default.dirname(healthPath), { recursive: true });
+  await import_node_fs5.promises.writeFile(healthPath, JSON.stringify(coverage), "utf8");
+}
+async function readExtractionHealth(healthPath) {
+  let raw;
+  try {
+    raw = await import_node_fs5.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;
+  }
+}
 function isStrictExtractionEnabled() {
   const raw = process.env.NEAT_STRICT_EXTRACTION;
   return raw === "1" || raw === "true";
@@ -3292,14 +3327,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_types6.fileId)(serviceName, relPath);
+  const svcAttrs = graph.hasNode(serviceNodeId) ? graph.getNodeAttributes(serviceNodeId) : void 0;
+  const canonicalService = svcAttrs && svcAttrs.type === import_types6.NodeType.ServiceNode && typeof svcAttrs.name === "string" ? svcAttrs.name : serviceName;
+  const relPath = reconcileObservedRelPath(graph, canonicalService, callSite.relPath);
+  const fileNodeId = (0, import_types6.fileId)(canonicalService, relPath);
   if (!graph.hasNode(fileNodeId)) {
     const language = languageForExt(relPath);
     const node = {
       id: fileNodeId,
       type: import_types6.NodeType.FileNode,
-      service: serviceName,
+      service: canonicalService,
       path: relPath,
       ...language ? { language } : {},
       ...callSite.originalRelPath ? { originalPath: callSite.originalRelPath } : {},
@@ -8424,6 +8461,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_path44.default.join(import_node_path44.default.dirname(opts.errorsPath), "rejected.ndjson");
@@ -10320,7 +10366,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;
@@ -10358,6 +10408,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,
@@ -10368,7 +10421,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 } : {}
       };
     });
   }
@@ -11010,12 +11064,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 [entry2];
     }
     try {
-      return await listProjects();
+      const entries = await listProjects();
+      return entries.map((entry2) => ({
+        ...entry2,
+        hostedHere: registry.has(entry2.name)
+      }));
     } catch (err) {
       return reply.code(500).send({
         error: "failed to read project registry",
@@ -11029,7 +11088,21 @@ async function buildApi(opts) {
       if (!entry2) {
         return reply.code(404).send({ error: "project not found", project: req.params.project });
       }
-      return { project: entry2 };
+      const hostedHere = registry.has(entry2.name);
+      if (!hostedHere) {
+        const owner = await findDaemonByProject(entry2.name).catch(() => void 0);
+        if (owner) {
+          return {
+            project: { ...entry2, hostedHere },
+            servedBy: {
+              path: owner.record.projectPath,
+              restPort: owner.record.ports.rest,
+              live: owner.live
+            }
+          };
+        }
+      }
+      return { project: { ...entry2, hostedHere } };
     } catch (err) {
       return reply.code(500).send({
         error: "failed to read project registry",