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

package/dist/cli.cjs

@@ -801,6 +801,7 @@ __export(cli_exports, {
   cwdProjectApplies: () => cwdProjectApplies,
   isLoopbackEndpoint: () => isLoopbackEndpoint,
   isNpxInvocation: () => isNpxInvocation,
+  loopbackResolutionHint: () => loopbackResolutionHint,
   main: () => main,
   parseArgs: () => parseArgs,
   printBanner: () => printBanner,
@@ -18500,6 +18501,36 @@ var import_types64 = 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;
@@ -18552,6 +18583,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;
@@ -18642,6 +18678,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);
@@ -18996,6 +19036,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_types65.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();
@@ -31503,7 +31552,7 @@ async function connectorAdd(args, deps) {
   }
   const { replaced } = await upsertConnectorEntry(entry2, deps.home);
   const verb = replaced ? "updated" : "added";
-  const where = project ? `project "${project}"` : "the bootstrapping project";
+  const where = project ? `project "${project}"` : "every project (no --project set)";
   deps.out(`${verb} connector "${id}" (${provider}) for ${where}.`);
   if (push) {
     deps.out("The drain is live \u2014 traces arrive at the daemon's OTLP receiver. No poll or restart needed.");
@@ -31566,7 +31615,7 @@ async function connectorList(deps, filterProject, json = false) {
   }
   deps.out("id	provider	project	credential");
   for (const e of entries) {
-    const project = e.project ?? "(bootstrapping project)";
+    const project = e.project ?? "(every project)";
     const credential = describeCredential(e.credential, deps.env).map((c) => {
       const status2 = c.status ? ` (${c.status})` : c.kind === "plaintext" ? " (plaintext)" : "";
       return c.field ? `${c.field}=${c.display}${status2}` : `${c.display}${status2}`;
@@ -32580,6 +32629,47 @@ var import_node_path96 = __toESM(require("path"), 1);
 // src/cli-client.ts
 init_cjs_shims();
 var import_types113 = require("@neat.is/types");
+
+// src/incidents-render.ts
+init_cjs_shims();
+function deployHintLines(ev) {
+  const a = ev.attributes;
+  if (!a) return [];
+  const s = (k) => typeof a[k] === "string" ? a[k] : void 0;
+  const n = (k) => typeof a[k] === "number" ? a[k] : void 0;
+  const arr = (k) => Array.isArray(a[k]) ? a[k].filter((x) => typeof x === "string") : [];
+  const fault = s("k8s.fault");
+  const env = arr("k8s.containerEnv");
+  const args = arr("k8s.containerArgs");
+  const log = s("k8s.processLog");
+  if (!fault && env.length === 0 && args.length === 0 && !log) return [];
+  const out = [];
+  if (fault) {
+    const bits = [fault];
+    const wr = s("k8s.waitingReason");
+    if (wr) bits.push(wr);
+    const rc = n("k8s.restartCount");
+    if (rc !== void 0) bits.push(`restarts=${rc}`);
+    const ec = n("k8s.exitCode");
+    if (ec !== void 0) bits.push(`exit=${ec}`);
+    const tr = s("k8s.terminatedReason");
+    if (tr) bits.push(tr);
+    out.push(`deploy: ${bits.join(" ")}`);
+  }
+  const cap = (xs, max) => {
+    const joined = xs.join("  ");
+    return joined.length > max ? `${joined.slice(0, max)}\u2026(+${xs.length} entries)` : joined;
+  };
+  if (env.length > 0) out.push(`env: ${cap(env, 700)}`);
+  if (args.length > 0) out.push(`args: ${cap(args, 300)}`);
+  if (log) {
+    const tail = log.split("\n").filter((l) => l.trim().length > 0).slice(-4);
+    if (tail.length > 0) out.push(`log: ${tail.join(" \u23CE ")}`);
+  }
+  return out;
+}
+
+// src/cli-client.ts
 var HttpError = class extends Error {
   constructor(status2, message, responseBody = "") {
     super(message);
@@ -32836,6 +32926,8 @@ async function runIncidents(client, input) {
     const blockLines = [];
     for (const ev of ordered) {
       blockLines.push(`  ${ev.timestamp} \u2014 ${ev.service}: ${ev.errorMessage}`);
+      if (ev.exceptionType) blockLines.push(`    exception: ${ev.exceptionType}`);
+      for (const l of deployHintLines(ev)) blockLines.push(`    ${l}`);
       blockLines.push(`    trace=${ev.traceId} span=${ev.spanId}`);
     }
     const target = input.nodeId ?? "the project";
@@ -33691,7 +33783,7 @@ var import_promises5 = __toESM(require("readline/promises"), 1);
 
 // src/agent-directive.generated.ts
 init_cjs_shims();
-var AGENT_DIRECTIVE = '## Query NEAT before searching files\n\nThis project has a live NEAT graph: code, data and infrastructure declarations\nfused with runtime traffic, incidents and supported provider telemetry. It can\nshow what exists, what actually ran, where a failure began, and what may break\nwhen a node changes. The graph is deterministic: the agent supplies the model;\nNEAT resolves named nodes and traverses recorded evidence rather than asking an\nLLM to infer architecture from file names.\n\nEvery claim carries provenance and confidence. `EXTRACTED` comes from recognized\nsource or configuration, `OBSERVED` from spans or supported provider signals,\n`INFERRED` from a bridged relationship, and `STALE` marks an observed edge that\nwent quiet. Missing runtime evidence does not prove a path never runs.\n\n**For questions about this system\'s behavior, structure, data dependencies,\nfailures, or change impact, call the MCP `ask` tool (`mcp__neat__ask`) before\nRead/Grep/Glob/Bash.** You do not need an exact node id. `ask` resolves names\nand routes to the relevant graph traversal, returning provenance-tagged facts.\nWhen MCP is unavailable, use the same door through the CLI:\n\n```\nnpx neat.is ask "why is checkout failing?"\nnpx neat.is ask "what breaks if I change the orders table?"\nnpx neat.is ask "what does the payments service depend on at runtime?"\n```\n\nFor a failure, ask first, then call `get_incident_card` on the named service,\nfile or symbol. The card combines the incident, likely cause, blast radius,\npolicies and divergence into a work order. Use `expand` one hop at a time and\n`relate` to test whether the suspected cause and symptom share a signal. Check\nprovenance and confidence before acting.\n\nBefore a change, use `get_blast_radius` and `check_policies` to see dependents\nand advisory architectural rules. Use `get_divergences` to compare declared\nintent with observed behavior, `get_graph_diff` to compare a saved snapshot\nwith the live graph, and `get_recent_stale_edges` when traffic goes quiet.\n`get_dependencies` maps a node\'s outgoing graph; `get_observed_dependencies`\nshows only seen runtime/provider calls. `semantic_search` finds node labels,\nnot arbitrary source text.\n\nRead source when the graph does not model what you need: comments, arbitrary\nstring literals, config details, unsupported syntax, or a repository that has\nnot been extracted or connected. If a graph answer is empty, check the daemon\nwith `npx neat.is list` or restart it with `npx neat.is up`; wire MCP with\n`npx neat.is skill --apply`.\n';
+var AGENT_DIRECTIVE = '## Let NEAT investigate before you search files\n\nThis project has NEAT. It does the investigation for this system so you can\nspend your effort on the code: what exists, what actually ran, where a failure\nbegan, and what a change will reach. It answers from a live graph that fuses\ncode, data and infrastructure declarations with runtime traffic, incidents and\nsupported provider telemetry. The graph is deterministic: you supply the\nreasoning about the fix; NEAT resolves named nodes and traverses recorded\nevidence rather than asking an LLM to infer architecture from file names.\n\nEvery claim carries provenance and confidence. `EXTRACTED` comes from recognized\nsource or configuration, `OBSERVED` from spans or supported provider signals,\n`INFERRED` from a bridged relationship, and `STALE` marks an observed edge that\nwent quiet. Missing runtime evidence does not prove a path never runs.\n\n**For questions about this system\'s behavior, structure, data dependencies,\nfailures, or change impact, call the MCP `ask` tool (`mcp__neat__ask`) before\nRead/Grep/Glob/Bash.** You do not need an exact node id. `ask` resolves names\nand routes to the relevant graph traversal, returning provenance-tagged facts.\nWhen MCP is unavailable, use the same door through the CLI:\n\n```\nnpx neat.is ask "why is checkout failing?"\nnpx neat.is ask "what breaks if I change the orders table?"\nnpx neat.is ask "what does the payments service depend on at runtime?"\n```\n\nFor a failure, call `get_incident_card` on the failing service, file or symbol\n(if you don\'t know which, `ask` what is failing first). The card is the\ninvestigation already done: the incident, its likely cause chain, blast radius,\nthe governing policies and divergence, in one work order. Use `expand` one hop\nat a time and `relate` to test whether the suspected cause and symptom share a\nsignal. Check provenance and confidence before acting.\n\nBefore a change, use `get_blast_radius` and `check_policies` to see dependents\nand advisory architectural rules. Use `get_divergences` to compare declared\nintent with observed behavior, `get_graph_diff` to compare a saved snapshot\nwith the live graph, and `get_recent_stale_edges` when traffic goes quiet.\n`get_dependencies` maps a node\'s outgoing graph; `get_observed_dependencies`\nshows only seen runtime/provider calls. `semantic_search` finds node labels,\nnot arbitrary source text.\n\nRead source when the graph does not model what you need: comments, arbitrary\nstring literals, config details, unsupported syntax, or a repository that has\nnot been extracted or connected. If a graph answer is empty, check the daemon\nwith `npx neat.is list` or restart it with `npx neat.is up`; wire MCP with\n`npx neat.is skill --apply`.\n';
 
 // src/welcome.ts
 var WORDMARK = [
@@ -33706,10 +33798,13 @@ function renderAgentSetupPrompt(project, restPort) {
   const endpoint2 = restPort === void 0 ? "The daemon endpoint is unavailable; run `npx neat.is up` to start it." : `The local daemon is serving it at http://127.0.0.1:${restPort}.`;
   return `NEAT is set up for project "${project}". ${endpoint2}
 
-NEAT models this software system as one graph: code, data, infrastructure,
-runtime traffic, incidents, and supported provider telemetry fused where evidence
-permits. Use it to see what exists, what actually ran, where a failure began, and
-what a change could affect. Missing observations do not prove a path never runs.
+NEAT does the investigation for this system, so you can spend your effort on the
+code. When something fails, call get_incident_card on the failing service, file
+or symbol: one work order with where the failure is, the cause chain (provenance
+on every hop), what a fix reaches, the policies that govern the code, and where
+code and runtime disagree. For anything else about how the system works, ask.
+NEAT answers from a live graph that fuses the code with what actually ran; a
+path it hasn't seen run is not proof the path never runs.
 
 1. Wire NEAT's MCP server into this agent session:
      npx neat.is skill --apply
@@ -33720,8 +33815,10 @@ what a change could affect. Missing observations do not prove a path never runs.
    If the daemon is unreachable, run \`npx neat.is up\`.
 
 ${AGENT_DIRECTIVE}
-As the app or tests run, traces fill the OBSERVED layer. Daemon log:
-neat-out/daemon.log. Reopen this door with \`npx neat.is welcome\`.`;
+Runtime evidence arrives once the app runs with NEAT attached: for Node, load
+.env.neat first (\`set -a; . ./.env.neat; set +a\`); for Python, start under
+\`opentelemetry-instrument\`. Daemon log: neat-out/daemon.log. Reopen this
+door with \`npx neat.is welcome\`.`;
 }
 function printHeader(out) {
   for (const line of WORDMARK) out(line);
@@ -36497,10 +36594,15 @@ async function main() {
     return;
   }
   if (cmd === "sync") {
+    const syncTarget = await resolveClientTarget({
+      ...parsed.project ? { project: parsed.project } : {},
+      ...parsed.profile ? { profile: parsed.profile } : {}
+    });
     const result = await runSync({
       ...parsed.project ? { project: parsed.project } : {},
       ...parsed.to ? { to: parsed.to } : {},
       ...parsed.token ? { token: parsed.token } : {},
+      daemonUrl: syncTarget.endpoint,
       dryRun: parsed.dryRun,
       noInstrument: parsed.noInstrument,
       sourceEdit: parsed.sourceEdit,
@@ -36659,9 +36761,28 @@ async function resolveClientTarget(opts = {}) {
     if (daemon) {
       return { endpoint: `http://localhost:${daemon.record.ports.rest}`, source: "daemon-record" };
     }
+  } else {
+    const live = (await discoverDaemons()).filter((d) => d.live);
+    if (live.length === 1) {
+      return {
+        endpoint: `http://localhost:${live[0].record.ports.rest}`,
+        source: "sole-daemon"
+      };
+    }
   }
   return { endpoint: "http://localhost:8080", source: "default" };
 }
+async function loopbackResolutionHint() {
+  const live = (await discoverDaemons()).filter((d) => d.live);
+  if (live.length === 0) {
+    return "No NEAT daemon is running. Start one with `npx neat.is` in your project (or `neat up`), then re-run \u2014 or set NEAT_API_URL to a daemon.";
+  }
+  if (live.length > 1) {
+    const list = live.map((d) => `  ${d.record.project} \u2192 http://localhost:${d.record.ports.rest}`).join("\n");
+    return "This directory is not a registered NEAT project and several daemons are running, so NEAT cannot pick one. Run from the project directory, pass --project <name>, or set NEAT_API_URL:\n" + list;
+  }
+  return void 0;
+}
 async function projectForCwd(cwd = process.cwd()) {
   try {
     return (await findProjectByPath(cwd))?.name;
@@ -36670,7 +36791,7 @@ async function projectForCwd(cwd = process.cwd()) {
   }
 }
 function cwdProjectApplies(source) {
-  return source === "daemon-record" || source === "default";
+  return source === "daemon-record" || source === "sole-daemon" || source === "default";
 }
 async function resolveDaemonUrl(project, profile) {
   return (await resolveClientTarget({ project, profile })).endpoint;
@@ -36692,6 +36813,11 @@ async function runQueryVerb(cmd, parsed) {
     }
     throw err;
   }
+  if (target.source === "default" && !requestedProject && !cwdProject) {
+    const hint = await loopbackResolutionHint();
+    if (hint) process.stderr.write(`${hint}
+`);
+  }
   const client = createHttpClient(target.endpoint, target.authToken);
   const positional = parsed.positional;
   let makeWork;
@@ -36939,6 +37065,7 @@ if (/[\\/](?:cli\.(?:cjs|js)|cli|neat|neat\.is)$/.test(entry)) {
   cwdProjectApplies,
   isLoopbackEndpoint,
   isNpxInvocation,
+  loopbackResolutionHint,
   main,
   parseArgs,
   printBanner,