@neat.is/core 0.7.0 → 0.7.2

package/dist/cli.d.cts

@@ -80,5 +80,6 @@ declare class ProjectResolutionError extends Error {
 declare function resolveProjectForVerb(client: HttpClient, parsed: ParsedArgs): Promise<string | undefined>;
 declare function resolveDaemonUrl(project?: string): Promise<string>;
 declare function runQueryVerb(cmd: string, parsed: ParsedArgs): Promise<number>;
+declare function runMonitorVerb(parsed: ParsedArgs): Promise<number>;
 
-export { CLAUDE_SKILL_CONFIG, type InitOptions, type InitResult, ProjectResolutionError, QUERY_VERBS, type SkillOptions, commandPrefix, isNpxInvocation, main, parseArgs, printBanner, readPackageVersion, resolveDaemonUrl, resolveProjectForVerb, runInit, runQueryVerb, runSkill, usage };
+export { CLAUDE_SKILL_CONFIG, type InitOptions, type InitResult, ProjectResolutionError, QUERY_VERBS, type SkillOptions, commandPrefix, isNpxInvocation, main, parseArgs, printBanner, readPackageVersion, resolveDaemonUrl, resolveProjectForVerb, runInit, runMonitorVerb, runQueryVerb, runSkill, usage };

package/dist/cli.d.ts

@@ -80,5 +80,6 @@ declare class ProjectResolutionError extends Error {
 declare function resolveProjectForVerb(client: HttpClient, parsed: ParsedArgs): Promise<string | undefined>;
 declare function resolveDaemonUrl(project?: string): Promise<string>;
 declare function runQueryVerb(cmd: string, parsed: ParsedArgs): Promise<number>;
+declare function runMonitorVerb(parsed: ParsedArgs): Promise<number>;
 
-export { CLAUDE_SKILL_CONFIG, type InitOptions, type InitResult, ProjectResolutionError, QUERY_VERBS, type SkillOptions, commandPrefix, isNpxInvocation, main, parseArgs, printBanner, readPackageVersion, resolveDaemonUrl, resolveProjectForVerb, runInit, runQueryVerb, runSkill, usage };
+export { CLAUDE_SKILL_CONFIG, type InitOptions, type InitResult, ProjectResolutionError, QUERY_VERBS, type SkillOptions, commandPrefix, isNpxInvocation, main, parseArgs, printBanner, readPackageVersion, resolveDaemonUrl, resolveProjectForVerb, runInit, runMonitorVerb, runQueryVerb, runSkill, usage };

package/dist/cli.js

@@ -6,7 +6,7 @@ import {
   resolveHost,
   resolveNeatVersion,
   writeDaemonRecord
-} from "./chunk-UBQ4ZZT3.js";
+} from "./chunk-MDBE23Y3.js";
 import {
   buildSearchIndex
 } from "./chunk-BIY46Q6U.js";
@@ -72,10 +72,10 @@ import {
   startStalenessLoop,
   upsertConnectorEntry,
   validateConnectorEntry
-} from "./chunk-5RIL3U5A.js";
+} from "./chunk-RR4LWQQB.js";
 import {
   startOtelGrpcReceiver
-} from "./chunk-Q6DPK3RA.js";
+} from "./chunk-6H757ZNM.js";
 import {
   __dirname,
   __require,
@@ -83,7 +83,7 @@ import {
   buildOtelReceiver,
   listenSteppingOtlp,
   readAuthEnv
-} from "./chunk-N5L3RBGP.js";
+} from "./chunk-P2ZEKJ35.js";
 
 // src/cli.ts
 import path11 from "path";
@@ -825,7 +825,7 @@ import semver from "semver";
 
 // src/installers/templates.ts
 var OTEL_INIT_HEADER = "// Generated by `neat init --apply` (ADR-069). OpenTelemetry auto-instrumentation hook.";
-var OTEL_INIT_STAMP = "// neat-template-version: 7 \u2014 OTel init degrades to no-OBSERVED instead of crashing the host app when @opentelemetry deps are absent (#820); daemon.json endpoint resolution (ADR-096) + layered file-first capture (ADR-090).";
+var OTEL_INIT_STAMP = "// neat-template-version: 8 \u2014 CommonJS TypeScript uses a synchronous bootstrap (#910); OTel init degrades to no-OBSERVED when dependencies are absent (#820); daemon.json endpoint resolution (ADR-096) + layered file-first capture (ADR-090).";
 var OTEL_OTLP_HEADERS_JS = "if (process.env.NEAT_OTEL_TOKEN) process.env.OTEL_EXPORTER_OTLP_HEADERS ||= 'Authorization=Bearer ' + process.env.NEAT_OTEL_TOKEN";
 var OTEL_OTLP_PROTOCOL_JS = "process.env.OTEL_EXPORTER_OTLP_PROTOCOL ||= 'http/json'";
 var OTEL_ENDPOINT_RESOLVER_CJS = `;(function () {
@@ -1189,6 +1189,13 @@ ${neatWireCaptureSource(false)}
   }
 }
 `;
+var OTEL_INIT_TS_CJS = OTEL_INIT_CJS.replace(
+  `${OTEL_INIT_HEADER}
+${OTEL_INIT_STAMP}`,
+  `${OTEL_INIT_HEADER}
+${OTEL_INIT_STAMP}
+// @ts-nocheck \u2014 generated CommonJS runtime shim.`
+);
 var OTEL_INIT_ESM = `${OTEL_INIT_HEADER}
 ${OTEL_INIT_STAMP}
 ${OTEL_ESM_NODE_IMPORTS}
@@ -1460,6 +1467,13 @@ function detectNonBundledInstrumentations(pkg) {
       registration: "instrumentations.push(new (require('@prisma/instrumentation').PrismaInstrumentation)())"
     });
   }
+  if (getMajor(deps["@nestjs/core"]) >= 11) {
+    out.push({
+      pkg: "@opentelemetry/instrumentation-nestjs-core",
+      version: "^0.67.0",
+      registration: "instrumentations.push(new (require('@opentelemetry/instrumentation-nestjs-core').NestInstrumentation)())"
+    });
+  }
   return out;
 }
 var OTEL_ENV = {
@@ -1772,18 +1786,19 @@ async function resolveEntry(serviceDir, pkg) {
 }
 function dispatchEntry(entryFile, pkg) {
   const ext = path5.extname(entryFile).toLowerCase();
-  if (ext === ".ts" || ext === ".tsx") return "ts";
+  if (ext === ".ts" || ext === ".tsx") return pkg.type === "module" ? "ts" : "ts-cjs";
   if (ext === ".mjs") return "esm";
   if (ext === ".cjs") return "cjs";
   return pkg.type === "module" ? "esm" : "cjs";
 }
 function otelInitFilename(flavor) {
-  if (flavor === "ts") return "otel-init.ts";
+  if (flavor === "ts" || flavor === "ts-cjs") return "otel-init.ts";
   if (flavor === "esm") return "otel-init.mjs";
   return "otel-init.cjs";
 }
 function otelInitContents(flavor) {
   if (flavor === "ts") return OTEL_INIT_TS;
+  if (flavor === "ts-cjs") return OTEL_INIT_TS_CJS;
   if (flavor === "esm") return OTEL_INIT_ESM;
   return OTEL_INIT_CJS;
 }
@@ -3575,8 +3590,8 @@ async function healthIsForProject(restPort, project) {
   }
   return false;
 }
-function daemonLogPath(projectPath2) {
-  return path8.join(projectPath2, "neat-out", "daemon.log");
+function daemonLogPath(projectPath3) {
+  return path8.join(projectPath3, "neat-out", "daemon.log");
 }
 function spawnDaemonDetached(spec) {
   const here = path8.dirname(fileURLToPath2(import.meta.url));
@@ -4440,8 +4455,8 @@ async function runHooksCommand(args) {
   }
 }
 
-// src/cli-verbs.ts
-import path10 from "path";
+// src/monitor.ts
+import { EdgeType, parseEdgeId, Provenance as Provenance3 } from "@neat.is/types";
 
 // src/cli-client.ts
 import { Provenance as Provenance2 } from "@neat.is/types";
@@ -4884,6 +4899,9 @@ function formatDivergenceLine(d) {
   switch (d.type) {
     case "missing-observed":
     case "missing-extracted":
+      if (d.column) {
+        return `  \u2022 [${d.type}] ${d.table ?? d.source} column ${d.column} \u2014 confidence ${d.confidence.toFixed(2)}`;
+      }
       return `  \u2022 [${d.type}] ${d.source} \u2192 ${d.target} (${d.edgeType}) \u2014 confidence ${d.confidence.toFixed(2)}`;
     case "version-mismatch":
       return `  \u2022 [${d.type}] ${d.source} \u2192 ${d.target} \u2014 declared ${d.extractedVersion}, observed engine ${d.observedVersion} (${d.compatibility})`;
@@ -4970,7 +4988,310 @@ async function pushSnapshotToRemote(input) {
   );
 }
 
+// src/monitor.ts
+var OBSERVED_DEP_EDGE_TYPES = /* @__PURE__ */ new Set([
+  EdgeType.CALLS,
+  EdgeType.CONNECTS_TO,
+  EdgeType.PUBLISHES_TO,
+  EdgeType.CONSUMES_FROM
+]);
+function divergenceKey(d) {
+  const column = "column" in d && d.column ? d.column : "";
+  const edgeType = "edgeType" in d && d.edgeType ? d.edgeType : "";
+  let extra = "";
+  switch (d.type) {
+    case "version-mismatch":
+      extra = `${d.extractedVersion}->${d.observedVersion}`;
+      break;
+    case "host-mismatch":
+      extra = `${d.extractedHost}->${d.observedHost}`;
+      break;
+    case "compat-violation":
+      extra = `${d.rule.kind}:${d.rule.package ?? ""}`;
+      break;
+    default:
+      extra = "";
+  }
+  return `div|${d.type}|${d.source}|${d.target}|${edgeType}|${column}|${extra}`;
+}
+function tableLabel(d) {
+  return "table" in d && d.table ? d.table : d.source;
+}
+function formatDivergenceLine2(d) {
+  switch (d.type) {
+    case "missing-observed":
+      if (d.column) {
+        return `\u26A0 divergence [missing-observed] ${tableLabel(d)}.${d.column} declared, never observed in production`;
+      }
+      return `\u26A0 divergence [missing-observed] ${d.source} \u2192 ${d.target} declared, never observed in production`;
+    case "missing-extracted":
+      if (d.column) {
+        return `\u26A0 divergence [missing-extracted] production writes ${tableLabel(d)}.${d.column} \u2014 not declared in code`;
+      }
+      return `\u26A0 divergence [missing-extracted] production ${d.source} \u2192 ${d.target} \u2014 not declared in code`;
+    case "version-mismatch":
+      return `\u26A0 divergence [version-mismatch] ${d.source} \u2192 ${d.target} declared ${d.extractedVersion}, observed ${d.observedVersion} (${d.compatibility})`;
+    case "host-mismatch":
+      return `\u26A0 divergence [host-mismatch] ${d.source} \u2192 ${d.target} declared host ${d.extractedHost}, observed host ${d.observedHost}`;
+    case "compat-violation":
+      return `\u26A0 divergence [compat-violation] ${d.source} \u2192 ${d.target} \u2014 ${d.rule.kind}${d.rule.package ? ` (${d.rule.package})` : ""}`;
+  }
+}
+function formatStaleLine(edgeId) {
+  const parsed = parseEdgeId(edgeId);
+  if (parsed) {
+    return `\u22EF stale  ${parsed.source} \u2192 ${parsed.target}  (observed edge went quiet)`;
+  }
+  return `\u22EF stale  ${edgeId}  (observed edge went quiet)`;
+}
+function formatObservedEdgeLine(edge) {
+  return `+ observed  ${edge.source} \u2192 ${edge.target}  (new runtime dependency)`;
+}
+function divergenceJson(d) {
+  return JSON.stringify({ kind: "divergence", ...d });
+}
+function staleJson(edgeId) {
+  const parsed = parseEdgeId(edgeId);
+  return JSON.stringify({
+    kind: "stale",
+    edgeId,
+    ...parsed ? { source: parsed.source, target: parsed.target, edgeType: parsed.type } : {}
+  });
+}
+function observedEdgeJson(edge) {
+  return JSON.stringify({
+    kind: "observed",
+    id: edge.id,
+    source: edge.source,
+    target: edge.target,
+    edgeType: edge.type,
+    provenance: edge.provenance
+  });
+}
+var MonitorEmitter = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  seen = /* @__PURE__ */ new Set();
+  out(line) {
+    this.opts.write(line + "\n");
+  }
+  // Emit every not-yet-seen divergence in a fresh result. Returns the count
+  // newly emitted (0 → nothing printed, the silent path). Idempotent across
+  // re-reads: the seen-set keys off divergenceKey.
+  emitDivergences(result) {
+    let emitted = 0;
+    for (const d of result.divergences) {
+      const key = divergenceKey(d);
+      if (this.seen.has(key)) continue;
+      this.seen.add(key);
+      this.out(this.opts.json ? divergenceJson(d) : formatDivergenceLine2(d));
+      emitted++;
+    }
+    return emitted;
+  }
+  // Emit a stale-transition once, keyed on the edge id.
+  emitStale(edgeId) {
+    const key = `stale|${edgeId}`;
+    if (this.seen.has(key)) return false;
+    this.seen.add(key);
+    this.out(this.opts.json ? staleJson(edgeId) : formatStaleLine(edgeId));
+    return true;
+  }
+  // Emit a new OBSERVED runtime dependency once, keyed on the edge id. Silently
+  // ignores non-OBSERVED edges and non-dependency edge types (structural
+  // ownership), so only real runtime dependencies reach stdout.
+  emitObservedEdge(edge) {
+    if (edge.provenance !== Provenance3.OBSERVED) return false;
+    if (!OBSERVED_DEP_EDGE_TYPES.has(edge.type)) return false;
+    const key = `edge|${edge.id}`;
+    if (this.seen.has(key)) return false;
+    this.seen.add(key);
+    this.out(this.opts.json ? observedEdgeJson(edge) : formatObservedEdgeLine(edge));
+    return true;
+  }
+};
+function parseFrame(raw) {
+  let event = "message";
+  const dataLines = [];
+  for (const line of raw.split("\n")) {
+    if (line.length === 0 || line.startsWith(":")) continue;
+    if (line.startsWith("event:")) {
+      event = line.slice("event:".length).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice("data:".length).replace(/^ /, ""));
+    }
+  }
+  if (dataLines.length === 0) return null;
+  return { event, data: dataLines.join("\n") };
+}
+async function drainSse(body, onFrame) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      buf = buf.replace(/\r\n/g, "\n");
+      let idx;
+      while ((idx = buf.indexOf("\n\n")) !== -1) {
+        const rawFrame = buf.slice(0, idx);
+        buf = buf.slice(idx + 2);
+        const frame = parseFrame(rawFrame);
+        if (frame) onFrame(frame);
+      }
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+function safeParse(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function projectPath2(project, suffix) {
+  if (!project) return suffix;
+  return `/projects/${encodeURIComponent(project)}${suffix}`;
+}
+function backoffDelay(attempt, capMs) {
+  return Math.min(capMs, 500 * 2 ** Math.min(attempt, 6));
+}
+async function runMonitor(opts) {
+  const write = opts.write ?? ((line) => process.stdout.write(line));
+  const debounceMs = opts.debounceMs ?? 400;
+  const backoffCapMs = opts.backoffCapMs ?? 1e4;
+  const maxReconnects = opts.maxReconnects ?? Number.POSITIVE_INFINITY;
+  const client = createHttpClient(opts.baseUrl, opts.authToken);
+  const emitter = new MonitorEmitter({ json: opts.json, write });
+  const divergencesPath = projectPath2(opts.project, "/graph/divergences");
+  const eventsUrl = `${opts.baseUrl.replace(/\/$/, "")}${projectPath2(opts.project, "/events")}`;
+  let readTimer = null;
+  let reading = false;
+  let readPending = false;
+  const doRead = async () => {
+    if (reading) {
+      readPending = true;
+      return;
+    }
+    reading = true;
+    try {
+      const result = await client.get(divergencesPath);
+      emitter.emitDivergences(result);
+    } catch {
+    } finally {
+      reading = false;
+      if (readPending) {
+        readPending = false;
+        scheduleRead();
+      }
+    }
+  };
+  const scheduleRead = () => {
+    if (readTimer) clearTimeout(readTimer);
+    readTimer = setTimeout(() => {
+      readTimer = null;
+      void doRead();
+    }, debounceMs);
+    if (typeof readTimer.unref === "function") readTimer.unref();
+  };
+  const onFrame = (frame) => {
+    switch (frame.event) {
+      case "extraction-complete":
+        scheduleRead();
+        break;
+      case "stale-transition": {
+        const payload = safeParse(frame.data);
+        const edgeId = payload && typeof payload.edgeId === "string" ? payload.edgeId : void 0;
+        if (edgeId) emitter.emitStale(edgeId);
+        scheduleRead();
+        break;
+      }
+      case "edge-added": {
+        const payload = safeParse(frame.data);
+        const edge = payload?.edge;
+        if (edge && edge.provenance === Provenance3.OBSERVED) {
+          emitter.emitObservedEdge(edge);
+          scheduleRead();
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  };
+  const headers = { accept: "text/event-stream" };
+  if (opts.authToken && opts.authToken.length > 0) {
+    headers.authorization = `Bearer ${opts.authToken}`;
+  }
+  let connectedOnce = false;
+  let firstConnect = true;
+  for (let attempt = 0; ; attempt++) {
+    if (opts.signal?.aborted) break;
+    let res;
+    try {
+      res = await fetch(eventsUrl, { headers, signal: opts.signal });
+    } catch (err) {
+      if (err.name === "AbortError") break;
+      if (!connectedOnce || attempt >= maxReconnects) break;
+      await sleep(backoffDelay(attempt, backoffCapMs), opts.signal);
+      continue;
+    }
+    if (!res.ok || !res.body) {
+      await res.body?.cancel().catch(() => {
+      });
+      if (!connectedOnce || attempt >= maxReconnects) break;
+      await sleep(backoffDelay(attempt, backoffCapMs), opts.signal);
+      continue;
+    }
+    connectedOnce = true;
+    attempt = 0;
+    if (firstConnect) {
+      firstConnect = false;
+      await doRead();
+    } else {
+      scheduleRead();
+    }
+    try {
+      await drainSse(res.body, onFrame);
+    } catch {
+    }
+    if (opts.signal?.aborted) break;
+    if (attempt >= maxReconnects) break;
+    await sleep(backoffDelay(attempt, backoffCapMs), opts.signal);
+  }
+  if (readTimer) clearTimeout(readTimer);
+  return 0;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    if (typeof timer.unref === "function") timer.unref();
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
 // src/cli-verbs.ts
+import path10 from "path";
 async function resolveProjectEntry(opts) {
   const entries = await listProjects();
   if (opts.project) {
@@ -5164,6 +5485,14 @@ function usage2() {
   console.log("  watch <path>   Start neat-core, watch <path>, re-extract on changes.");
   console.log("                 PORT (default 8080), OTEL_PORT (4318), HOST (0.0.0.0)");
   console.log("                 control listeners. NEAT_OTLP_GRPC=true also opens 4317.");
+  console.log("  monitor        Stream live graph facts to stdout \u2014 one line per new");
+  console.log("                 fact \u2014 as the daemon learns them: fresh divergences,");
+  console.log("                 integrations that just went stale, and new observed");
+  console.log("                 runtime dependencies. Silent when nothing is new; exits");
+  console.log("                 clean with no output when no daemon is reachable.");
+  console.log("                 Flags:");
+  console.log("                   --project <name>   watch a registered project by name");
+  console.log("                   --json             emit one JSON object per line");
   console.log("  list           Report the daemons running on this machine (alias: ps).");
   console.log("                 Reads ~/.neat/daemons/ and folds in any registered");
   console.log("                 project no daemon has self-described yet.");
@@ -5823,14 +6152,14 @@ async function main() {
       console.error(`neat uninstall: no project named "${name}"`);
       process.exit(1);
     }
-    const projectPath2 = daemon?.record.projectPath ?? removed?.path ?? "(unknown path)";
+    const projectPath3 = daemon?.record.projectPath ?? removed?.path ?? "(unknown path)";
     if (daemon) {
       if (daemon.live && signalDaemonStop(daemon.record.pid)) {
         console.log(`uninstall: ${name} \u2014 stopped daemon pid ${daemon.record.pid}`);
       }
       await removeDaemonRecord(daemon.source);
     }
-    console.log(`unregistered: ${name} (${projectPath2})`);
+    console.log(`unregistered: ${name} (${projectPath3})`);
     console.log("note: neat-out/, policy.json, and other files at the project path were left in place.");
     return;
   }
@@ -5885,6 +6214,11 @@ async function main() {
     if (result.exitCode !== 0) process.exit(result.exitCode);
     return;
   }
+  if (cmd === "monitor") {
+    const code = await runMonitorVerb(parsed);
+    if (code !== 0) process.exit(code);
+    return;
+  }
   if (QUERY_VERBS.has(cmd)) {
     const code = await runQueryVerb(cmd, parsed);
     if (code !== 0) process.exit(code);
@@ -6138,6 +6472,37 @@ async function runQueryVerb(cmd, parsed) {
     return exitCodeForError(err);
   }
 }
+async function runMonitorVerb(parsed) {
+  const requestedProject = resolveProjectFlag(parsed);
+  const baseUrl = await resolveDaemonUrl(requestedProject);
+  const token = resolveAuthToken();
+  const client = createHttpClient(baseUrl, token);
+  let project;
+  try {
+    project = await resolveProjectForVerb(client, parsed);
+  } catch (err) {
+    if (err instanceof ProjectResolutionError) {
+      console.error(`neat monitor: ${err.message}`);
+    }
+    return 0;
+  }
+  const controller = new AbortController();
+  const onSignal = () => controller.abort();
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  try {
+    return await runMonitor({
+      baseUrl,
+      project,
+      json: parsed.json,
+      authToken: token,
+      signal: controller.signal
+    });
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+  }
+}
 var entry = process.argv[1] ?? "";
 if (/[\\/](?:cli\.(?:cjs|js)|cli|neat|neat\.is)$/.test(entry)) {
   main().catch((err) => {
@@ -6158,6 +6523,7 @@ export {
   resolveDaemonUrl,
   resolveProjectForVerb,
   runInit,
+  runMonitorVerb,
   runQueryVerb,
   runSkill,
   usage2 as usage