@neat.is/core 0.10.6 → 0.10.7-dev.20261011

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   routeSpanToProject,
   startDaemon
-} from "./chunk-OKM4N7GH.js";
+} from "./chunk-S5S2FYCQ.js";
 import {
   buildApi,
   checkCompatibility,
@@ -25,7 +25,7 @@ import {
   startStalenessLoop,
   stitchTrace,
   thresholdForEdgeType
-} from "./chunk-MW2XYLCS.js";
+} from "./chunk-6K22WGO7.js";
 import {
   ProjectNameCollisionError,
   addProject,

package/dist/neatd.cjs

@@ -18149,6 +18149,36 @@ var import_types62 = require("@neat.is/types");
 var CODE_FILEPATH_ATTR2 = "code.filepath";
 var CODE_LINENO_ATTR2 = "code.lineno";
 var BLAST_NEAREST_LIMIT = 5;
+function deployContextOf(ev) {
+  const a = ev.attributes;
+  if (!a) return void 0;
+  const str = (k) => typeof a[k] === "string" ? a[k] : void 0;
+  const int = (k) => typeof a[k] === "number" && Number.isFinite(a[k]) ? Math.trunc(a[k]) : void 0;
+  const strs = (k) => {
+    const v = a[k];
+    return Array.isArray(v) && v.every((x) => typeof x === "string") && v.length > 0 ? v : void 0;
+  };
+  const ctx = {};
+  const fault = str("k8s.fault");
+  if (fault) ctx.fault = fault;
+  const waiting = str("k8s.waitingReason");
+  if (waiting) ctx.waitingReason = waiting;
+  const image = str("k8s.image");
+  if (image) ctx.image = image;
+  const restarts = int("k8s.restartCount");
+  if (restarts !== void 0) ctx.restartCount = restarts;
+  const termReason = str("k8s.terminatedReason");
+  if (termReason) ctx.terminatedReason = termReason;
+  const exitCode = int("k8s.exitCode");
+  if (exitCode !== void 0) ctx.exitCode = exitCode;
+  const env = strs("k8s.containerEnv");
+  if (env) ctx.containerEnv = env;
+  const args = strs("k8s.containerArgs");
+  if (args) ctx.containerArgs = args;
+  const log = str("k8s.processLog");
+  if (log) ctx.processLog = log;
+  return Object.keys(ctx).length > 0 ? ctx : void 0;
+}
 function grainOf2(graph, nodeId) {
   if (graph.hasNode(nodeId)) {
     const t = graph.getNodeAttributes(nodeId).type;
@@ -18201,6 +18231,11 @@ function promoteCauseLocus(graph, causeNode, incidents) {
   return locusFromNode(graph, causeNode);
 }
 function divergenceSummary(d) {
+  if (d.type === "observed-symbol-mismatch" || d.source === d.target) {
+    const symbol = "symbol" in d && d.symbol ? d.symbol : d.source;
+    const at = "location" in d && d.location ? ` at ${d.location}` : "";
+    return `${symbol}${at}`;
+  }
   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;
@@ -18291,6 +18326,10 @@ function buildIncidentCard(graph, errorEvent, incidents, policies) {
     ...nearest.length > 0 ? { blastRadius: { totalAffected: blast.totalAffected, nearest } } : {},
     ...policyCards.length > 0 ? { policies: policyCards } : {},
     ...divergences.length > 0 ? { divergence: divergences } : {},
+    ...(() => {
+      const dc = deployContextOf(errorEvent);
+      return dc ? { deployContext: dc } : {};
+    })(),
     headline: renderHeadline(graph, errorEvent, locus, rootCause?.node ?? null)
   };
   card.grade = gradeIncidentCard(card);
@@ -18645,6 +18684,15 @@ var TYPE_NOUNS = [
 ];
 var EMBED_MIN_SCORE = 0.35;
 async function resolveEntities(graph, question, searchIndex, maxNodes) {
+  const verbatim = [];
+  for (const word of question.split(/\s+/)) {
+    const id = word.replace(/^["'`(<]+|["'`)>?!.,;]+$/g, "");
+    if (!id || !graph.hasNode(id) || verbatim.some((m) => m.nodeId === id)) continue;
+    const node = graph.getNodeAttributes(id);
+    if (node.type === import_types63.NodeType.FrontierNode) continue;
+    verbatim.push({ nodeId: id, label: nodeName(node), via: "id", score: 1 });
+  }
+  if (verbatim.length > 0) return { matched: verbatim.slice(0, maxNodes) };
   const qTokens = queryTokens(question);
   const normalized = question.toLowerCase();
   const best = /* @__PURE__ */ new Map();
@@ -25292,7 +25340,7 @@ function credentialRecord(provider, cred) {
       return { token: cred.accessToken };
   }
 }
-function hostedOptions(provider, summary, serviceName, firebaseServiceMap) {
+function hostedOptions(provider, summary, serviceName, firebaseServiceMap, serviceMaps = {}) {
   switch (provider) {
     case "supabase": {
       const ref = summary.projectRef;
@@ -25311,9 +25359,12 @@ function hostedOptions(provider, summary, serviceName, firebaseServiceMap) {
     case "firebase": {
       return { inferServices: true, excludeCloudRun: true, ...firebaseServiceMap ?? {} };
     }
+    // Same no-setup rule as Firebase: infer the owning service from the graph; an unknown one stays coarse.
+    // NEAT_CLOUD_RUN_SERVICE_MAP / NEAT_GCP_LB_BACKEND_SERVICE_MAP are optional overrides whose entries win.
     case "cloud-run":
+      return { inferServices: true, ...serviceMaps.cloudRun ? { serviceMap: serviceMaps.cloudRun } : {} };
     case "gcp-lb":
-      return { inferServices: true };
+      return { inferServices: true, ...serviceMaps.gcpLb ? { backendServiceMap: serviceMaps.gcpLb } : {} };
     default:
       return null;
   }
@@ -25338,6 +25389,19 @@ function parseFirebaseServiceMap(raw) {
     return void 0;
   }
 }
+function parseServiceNameMap(raw) {
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    const entries = Object.entries(parsed);
+    if (entries.length === 0) return void 0;
+    if (entries.some(([, v]) => typeof v !== "string" || v.length === 0)) return void 0;
+    return Object.fromEntries(entries);
+  } catch {
+    return void 0;
+  }
+}
 function pushHandlesPath(projectDir) {
   return (0, import_node_path79.join)(projectDir, "neat-out", "connectors-hosted.json");
 }
@@ -25459,7 +25523,10 @@ function startConnectionLoops(c, input, startLoop) {
       onSkip?.(name, "no project selected yet \u2014 not pullable");
       continue;
     }
-    const options = hostedOptions(name, c, project, input.firebaseServiceMap);
+    const options = hostedOptions(name, c, project, input.firebaseServiceMap, {
+      ...input.cloudRunServiceMap ? { cloudRun: input.cloudRunServiceMap } : {},
+      ...input.gcpLbBackendServiceMap ? { gcpLb: input.gcpLbBackendServiceMap } : {}
+    });
     if (!options) {
       onSkip?.(name, "no hosted option mapping for this provider");
       continue;
@@ -25569,6 +25636,8 @@ async function maybeStartHostedConnectors(input) {
     projectDir: input.projectDir,
     project: input.project,
     ...parseFirebaseServiceMap(env.NEAT_FIREBASE_SERVICE_MAP) ? { firebaseServiceMap: parseFirebaseServiceMap(env.NEAT_FIREBASE_SERVICE_MAP) } : {},
+    ...parseServiceNameMap(env.NEAT_CLOUD_RUN_SERVICE_MAP) ? { cloudRunServiceMap: parseServiceNameMap(env.NEAT_CLOUD_RUN_SERVICE_MAP) } : {},
+    ...parseServiceNameMap(env.NEAT_GCP_LB_BACKEND_SERVICE_MAP) ? { gcpLbBackendServiceMap: parseServiceNameMap(env.NEAT_GCP_LB_BACKEND_SERVICE_MAP) } : {},
     ...input.errorsPath ? { errorsPath: input.errorsPath } : {},
     ...input.onSkip ? { onSkip: input.onSkip } : {},
     ...input.intervalMs !== void 0 ? { intervalMs: input.intervalMs } : {}
@@ -27250,10 +27319,10 @@ async function pickInternalPort() {
   });
 }
 async function spawnWebUI(restPort, opts = {}) {
-  const root = projectRoot();
+  const root = opts.projectRoot ? import_node_path83.default.resolve(opts.projectRoot) : projectRoot();
   const fromDaemon = await readDaemonPorts(root);
   const { webPort: port, apiUrl } = resolveWebPorts({
-    daemonWeb: fromDaemon.web,
+    daemonWeb: fromDaemon.web ?? asValidPort(opts.webPort),
     daemonRest: fromDaemon.rest,
     webPortEnv: process.env.NEAT_WEB_PORT,
     apiUrlEnv: process.env.NEAT_API_URL,
@@ -27534,7 +27603,10 @@ async function cmdStart() {
   let web = null;
   if (!skipWeb) {
     try {
-      web = await spawnWebUI(restPortFromEnv());
+      web = await spawnWebUI(
+        restPortFromEnv(),
+        projectPath ? { projectRoot: projectPath, webPort: handle.daemonRecord?.ports.web } : {}
+      );
     } catch (err) {
       console.error(err.message);
       await handle.stop().catch(() => {