@neat.is/core 0.2.7 → 0.2.8

package/dist/index.cjs

@@ -100,8 +100,8 @@ function reshapeGrpcRequest(req) {
   };
 }
 function resolveProtoRoot() {
-  const here = import_node_path29.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
-  return import_node_path29.default.resolve(here, "..", "proto");
+  const here = import_node_path30.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+  return import_node_path30.default.resolve(here, "..", "proto");
 }
 function loadTraceService() {
   const protoRoot = resolveProtoRoot();
@@ -156,13 +156,13 @@ async function startOtelGrpcReceiver(opts) {
     })
   };
 }
-var import_node_url, import_node_path29, grpc, protoLoader;
+var import_node_url, import_node_path30, grpc, protoLoader;
 var init_otel_grpc = __esm({
   "src/otel-grpc.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_url = require("url");
-    import_node_path29 = __toESM(require("path"), 1);
+    import_node_path30 = __toESM(require("path"), 1);
     grpc = __toESM(require("@grpc/grpc-js"), 1);
     protoLoader = __toESM(require("@grpc/proto-loader"), 1);
     init_otel();
@@ -259,10 +259,10 @@ function parseOtlpRequest(body) {
 }
 function loadProtobufDecoder() {
   if (exportTraceServiceRequestType) return exportTraceServiceRequestType;
-  const here = import_node_path30.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
-  const protoRoot = import_node_path30.default.resolve(here, "..", "proto");
+  const here = import_node_path31.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
+  const protoRoot = import_node_path31.default.resolve(here, "..", "proto");
   const root = new import_protobufjs.default.Root();
-  root.resolvePath = (_origin, target) => import_node_path30.default.resolve(protoRoot, target);
+  root.resolvePath = (_origin, target) => import_node_path31.default.resolve(protoRoot, target);
   root.loadSync(
     "opentelemetry/proto/collector/trace/v1/trace_service.proto",
     { keepCase: true }
@@ -362,12 +362,12 @@ function logSpanHandler(span) {
     `otel: ${span.service} ${span.name} parent=${parent} status=${status2}${db}`
   );
 }
-var import_node_path30, import_node_url2, import_fastify2, import_protobufjs, exportTraceServiceRequestType;
+var import_node_path31, import_node_url2, import_fastify2, import_protobufjs, exportTraceServiceRequestType;
 var init_otel = __esm({
   "src/otel.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_path30 = __toESM(require("path"), 1);
+    import_node_path31 = __toESM(require("path"), 1);
     import_node_url2 = require("url");
     import_fastify2 = __toESM(require("fastify"), 1);
     import_protobufjs = __toESM(require("protobufjs"), 1);
@@ -777,6 +777,18 @@ function deprecatedApis() {
   return currentMatrix().deprecatedApis ?? [];
 }
 
+// src/events.ts
+init_cjs_shims();
+var import_node_events = require("events");
+var EVENT_BUS_CHANNEL = "event";
+var NeatEventBus = class extends import_node_events.EventEmitter {
+};
+var eventBus = new NeatEventBus();
+eventBus.setMaxListeners(0);
+function emitNeatEvent(envelope) {
+  eventBus.emit(EVENT_BUS_CHANNEL, envelope);
+}
+
 // src/traverse.ts
 init_cjs_shims();
 var import_types = require("@neat.is/types");
@@ -1340,9 +1352,11 @@ async function loadPolicyFile(policyPath) {
 }
 var PolicyViolationsLog = class {
   path;
+  project;
   seen = null;
-  constructor(logPath) {
+  constructor(logPath, project = DEFAULT_PROJECT) {
     this.path = logPath;
+    this.project = project;
   }
   async append(v) {
     if (!this.seen) await this.hydrate();
@@ -1350,6 +1364,11 @@ var PolicyViolationsLog = class {
     this.seen.add(v.id);
     await import_node_fs2.promises.mkdir(import_node_path2.default.dirname(this.path), { recursive: true });
     await import_node_fs2.promises.appendFile(this.path, JSON.stringify(v) + "\n", "utf8");
+    emitNeatEvent({
+      type: "policy-violation",
+      project: this.project,
+      payload: { violation: v }
+    });
     return true;
   }
   async readAll() {
@@ -1796,6 +1815,7 @@ async function markStaleEdges(graph, options = {}) {
   const thresholds = options.thresholds ?? loadStaleThresholdsFromEnv();
   const now = options.now ?? Date.now();
   const events = [];
+  const project = options.project ?? DEFAULT_PROJECT;
   graph.forEachEdge((id, attrs) => {
     const e = attrs;
     if (e.provenance !== import_types3.Provenance.OBSERVED) return;
@@ -1815,6 +1835,15 @@ async function markStaleEdges(graph, options = {}) {
         lastObserved: e.lastObserved,
         transitionedAt: new Date(now).toISOString()
       });
+      emitNeatEvent({
+        type: "stale-transition",
+        project,
+        payload: {
+          edgeId: id,
+          from: import_types3.Provenance.OBSERVED,
+          to: import_types3.Provenance.STALE
+        }
+      });
     }
   });
   if (options.staleEventsPath && events.length > 0) {
@@ -1845,7 +1874,8 @@ function startStalenessLoop(graph, options = {}) {
       try {
         await markStaleEdges(graph, {
           thresholds: options.thresholds,
-          staleEventsPath: options.staleEventsPath
+          staleEventsPath: options.staleEventsPath,
+          project: options.project
         });
         if (options.onPolicyTrigger) await options.onPolicyTrigger(graph);
       } catch (err) {
@@ -3075,7 +3105,15 @@ async function addHttpCallEdges(graph, services) {
     const seenTargets = /* @__PURE__ */ new Map();
     for (const file of files) {
       const parser = import_node_path18.default.extname(file.path) === ".py" ? pyParser : jsParser;
-      const targets = callsFromSource(file.content, parser, knownHosts);
+      let targets;
+      try {
+        targets = callsFromSource(file.content, parser, knownHosts);
+      } catch (err) {
+        console.warn(
+          `[neat] http call extraction skipped ${file.path}: ${err.message}`
+        );
+        continue;
+      }
       for (const t of targets) {
         const targetId = hostToNodeId.get(t);
         if (!targetId || targetId === service.node.id) continue;
@@ -3604,11 +3642,22 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
   const phase5 = await addInfra(graph, scanPath, services);
   const frontiersPromoted = promoteFrontierNodes(graph);
   if (opts.onPolicyTrigger) await opts.onPolicyTrigger(graph);
-  return {
+  const result = {
     nodesAdded: phase1Nodes + phase2.nodesAdded + phase3.nodesAdded + phase4.nodesAdded + phase5.nodesAdded,
     edgesAdded: phase2.edgesAdded + phase3.edgesAdded + phase4.edgesAdded + phase5.edgesAdded,
     frontiersPromoted
   };
+  emitNeatEvent({
+    type: "extraction-complete",
+    project: opts.project ?? DEFAULT_PROJECT,
+    payload: {
+      project: opts.project ?? DEFAULT_PROJECT,
+      fileCount: services.length,
+      nodesAdded: result.nodesAdded,
+      edgesAdded: result.edgesAdded
+    }
+  });
+  return result;
 }
 
 // src/persist.ts
@@ -3699,7 +3748,7 @@ function startPersistLoop(graph, outPath, intervalMs = 6e4) {
 init_cjs_shims();
 var import_fastify = __toESM(require("fastify"), 1);
 var import_cors = __toESM(require("@fastify/cors"), 1);
-var import_types18 = require("@neat.is/types");
+var import_types19 = require("@neat.is/types");
 
 // src/diff.ts
 init_cjs_shims();
@@ -3830,6 +3879,229 @@ var Projects = class {
   }
 };
 
+// src/registry.ts
+init_cjs_shims();
+var import_node_fs17 = require("fs");
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path29 = __toESM(require("path"), 1);
+var import_types18 = require("@neat.is/types");
+var LOCK_TIMEOUT_MS = 5e3;
+var LOCK_RETRY_MS = 50;
+function neatHome() {
+  const override = process.env.NEAT_HOME;
+  if (override && override.length > 0) return import_node_path29.default.resolve(override);
+  return import_node_path29.default.join(import_node_os2.default.homedir(), ".neat");
+}
+function registryPath() {
+  return import_node_path29.default.join(neatHome(), "projects.json");
+}
+function registryLockPath() {
+  return import_node_path29.default.join(neatHome(), "projects.json.lock");
+}
+async function normalizeProjectPath(input) {
+  const resolved = import_node_path29.default.resolve(input);
+  try {
+    return await import_node_fs17.promises.realpath(resolved);
+  } catch {
+    return resolved;
+  }
+}
+async function writeAtomically(target, contents) {
+  await import_node_fs17.promises.mkdir(import_node_path29.default.dirname(target), { recursive: true });
+  const tmp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+  const fd = await import_node_fs17.promises.open(tmp, "w");
+  try {
+    await fd.writeFile(contents, "utf8");
+    await fd.sync();
+  } finally {
+    await fd.close();
+  }
+  await import_node_fs17.promises.rename(tmp, target);
+}
+async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  await import_node_fs17.promises.mkdir(import_node_path29.default.dirname(lockPath), { recursive: true });
+  while (true) {
+    try {
+      const fd = await import_node_fs17.promises.open(lockPath, "wx");
+      await fd.close();
+      return;
+    } catch (err) {
+      const code = err.code;
+      if (code !== "EEXIST") throw err;
+      if (Date.now() >= deadline) {
+        throw new Error(
+          `neat registry: timed out after ${timeoutMs}ms waiting for ${lockPath}. Another neat process is holding the lock; if no such process exists, remove the file by hand.`
+        );
+      }
+      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
+    }
+  }
+}
+async function releaseLock(lockPath) {
+  await import_node_fs17.promises.unlink(lockPath).catch(() => {
+  });
+}
+async function withLock(fn) {
+  const lock = registryLockPath();
+  await acquireLock(lock);
+  try {
+    return await fn();
+  } finally {
+    await releaseLock(lock);
+  }
+}
+async function readRegistry() {
+  const file = registryPath();
+  let raw;
+  try {
+    raw = await import_node_fs17.promises.readFile(file, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { version: 1, projects: [] };
+    }
+    throw err;
+  }
+  const parsed = JSON.parse(raw);
+  return import_types18.RegistryFileSchema.parse(parsed);
+}
+async function writeRegistry(reg) {
+  const validated = import_types18.RegistryFileSchema.parse(reg);
+  await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + "\n");
+}
+var ProjectNameCollisionError = class extends Error {
+  projectName;
+  constructor(name) {
+    super(`neat registry: a project named "${name}" is already registered`);
+    this.name = "ProjectNameCollisionError";
+    this.projectName = name;
+  }
+};
+async function addProject(opts) {
+  const resolvedPath = await normalizeProjectPath(opts.path);
+  return withLock(async () => {
+    const reg = await readRegistry();
+    const byName = reg.projects.find((p) => p.name === opts.name);
+    const byPath = reg.projects.find((p) => p.path === resolvedPath);
+    if (byName && byName.path !== resolvedPath) {
+      throw new ProjectNameCollisionError(opts.name);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (byName && byName.path === resolvedPath) {
+      byName.lastSeenAt = now;
+      if (opts.languages) byName.languages = opts.languages;
+      if (opts.status) byName.status = opts.status;
+      await writeRegistry(reg);
+      return byName;
+    }
+    if (byPath && byPath.name !== opts.name) {
+      throw new ProjectNameCollisionError(byPath.name);
+    }
+    const entry = {
+      name: opts.name,
+      path: resolvedPath,
+      registeredAt: now,
+      languages: opts.languages ?? [],
+      status: opts.status ?? "active"
+    };
+    reg.projects.push(entry);
+    await writeRegistry(reg);
+    return entry;
+  });
+}
+async function getProject(name) {
+  const reg = await readRegistry();
+  return reg.projects.find((p) => p.name === name);
+}
+async function listProjects() {
+  const reg = await readRegistry();
+  return reg.projects;
+}
+async function setStatus(name, status2) {
+  return withLock(async () => {
+    const reg = await readRegistry();
+    const entry = reg.projects.find((p) => p.name === name);
+    if (!entry) throw new Error(`neat registry: no project named "${name}"`);
+    entry.status = status2;
+    await writeRegistry(reg);
+    return entry;
+  });
+}
+async function touchLastSeen(name, at = (/* @__PURE__ */ new Date()).toISOString()) {
+  await withLock(async () => {
+    const reg = await readRegistry();
+    const entry = reg.projects.find((p) => p.name === name);
+    if (!entry) return;
+    entry.lastSeenAt = at;
+    await writeRegistry(reg);
+  });
+}
+async function removeProject(name) {
+  return withLock(async () => {
+    const reg = await readRegistry();
+    const idx = reg.projects.findIndex((p) => p.name === name);
+    if (idx < 0) return void 0;
+    const [removed] = reg.projects.splice(idx, 1);
+    await writeRegistry(reg);
+    return removed;
+  });
+}
+
+// src/streaming.ts
+init_cjs_shims();
+var SSE_HEARTBEAT_MS = 3e4;
+var SSE_BACKPRESSURE_CAP = 1e3;
+function handleSse(req, reply, opts) {
+  const heartbeatMs = opts.heartbeatMs ?? SSE_HEARTBEAT_MS;
+  const backpressureCap = opts.backpressureCap ?? SSE_BACKPRESSURE_CAP;
+  reply.raw.setHeader("Content-Type", "text/event-stream");
+  reply.raw.setHeader("Cache-Control", "no-cache, no-transform");
+  reply.raw.setHeader("Connection", "keep-alive");
+  reply.raw.setHeader("X-Accel-Buffering", "no");
+  reply.raw.flushHeaders?.();
+  let pending = 0;
+  let dropped = false;
+  const closeConnection = () => {
+    if (dropped) return;
+    dropped = true;
+    eventBus.off(EVENT_BUS_CHANNEL, listener);
+    clearInterval(heartbeat);
+    if (!reply.raw.writableEnded) reply.raw.end();
+  };
+  const writeFrame = (frame) => {
+    if (dropped) return;
+    if (pending >= backpressureCap) {
+      const errFrame = `event: error
+data: ${JSON.stringify({ reason: "backpressure" })}
+
+`;
+      reply.raw.write(errFrame);
+      closeConnection();
+      return;
+    }
+    pending++;
+    reply.raw.write(frame, () => {
+      pending = Math.max(0, pending - 1);
+    });
+  };
+  const listener = (envelope) => {
+    if (envelope.project !== opts.project) return;
+    writeFrame(`event: ${envelope.type}
+data: ${JSON.stringify(envelope.payload)}
+
+`);
+  };
+  eventBus.on(EVENT_BUS_CHANNEL, listener);
+  const heartbeat = setInterval(() => {
+    if (dropped) return;
+    reply.raw.write(":heartbeat\n\n");
+  }, heartbeatMs);
+  if (typeof heartbeat.unref === "function") heartbeat.unref();
+  req.raw.on("close", closeConnection);
+  reply.raw.on("close", closeConnection);
+  reply.raw.on("error", closeConnection);
+}
+
 // src/api.ts
 function serializeGraph(graph) {
   const nodes = [];
@@ -3878,6 +4150,11 @@ function buildLegacyRegistry(opts) {
 }
 function registerRoutes(scope, ctx) {
   const { registry, startedAt, errorsPathFor, staleEventsPathFor } = ctx;
+  scope.get("/events", (req, reply) => {
+    const proj = resolveProject(registry, req, reply);
+    if (!proj) return;
+    handleSse(req, reply, { project: proj.name });
+  });
   scope.get("/health", async (req, reply) => {
     const proj = resolveProject(registry, req, reply);
     if (!proj) return;
@@ -4088,7 +4365,7 @@ function registerRoutes(scope, ctx) {
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
     if (req.query.severity) {
-      const sev = import_types18.PolicySeveritySchema.safeParse(req.query.severity);
+      const sev = import_types19.PolicySeveritySchema.safeParse(req.query.severity);
       if (!sev.success) {
         return reply.code(400).send({
           error: "invalid severity",
@@ -4105,7 +4382,7 @@ function registerRoutes(scope, ctx) {
   scope.post("/policies/check", async (req, reply) => {
     const proj = resolveProject(registry, req, reply);
     if (!proj) return;
-    const parsed = import_types18.PoliciesCheckBodySchema.safeParse(req.body ?? {});
+    const parsed = import_types19.PoliciesCheckBodySchema.safeParse(req.body ?? {});
     if (!parsed.success) {
       return reply.code(400).send({
         error: "invalid /policies/check body",
@@ -4169,17 +4446,16 @@ async function buildApi(opts) {
     staleEventsPathFor,
     policyFilePathFor
   };
-  app.get("/projects", async () => ({
-    projects: registry.list().map((name) => {
-      const proj = registry.get(name);
-      return {
-        name,
-        nodeCount: proj.graph.order,
-        edgeCount: proj.graph.size,
-        scanPath: proj.scanPath
-      };
-    })
-  }));
+  app.get("/projects", async (_req, reply) => {
+    try {
+      return await listProjects();
+    } catch (err) {
+      return reply.code(500).send({
+        error: "failed to read project registry",
+        details: err.message
+      });
+    }
+  });
   registerRoutes(app, routeCtx);
   await app.register(
     async (scope) => {
@@ -4198,176 +4474,6 @@ init_otel_grpc();
 init_cjs_shims();
 var import_node_fs18 = require("fs");
 var import_node_path32 = __toESM(require("path"), 1);
-
-// src/registry.ts
-init_cjs_shims();
-var import_node_fs17 = require("fs");
-var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path31 = __toESM(require("path"), 1);
-var import_types19 = require("@neat.is/types");
-var LOCK_TIMEOUT_MS = 5e3;
-var LOCK_RETRY_MS = 50;
-function neatHome() {
-  const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return import_node_path31.default.resolve(override);
-  return import_node_path31.default.join(import_node_os2.default.homedir(), ".neat");
-}
-function registryPath() {
-  return import_node_path31.default.join(neatHome(), "projects.json");
-}
-function registryLockPath() {
-  return import_node_path31.default.join(neatHome(), "projects.json.lock");
-}
-async function normalizeProjectPath(input) {
-  const resolved = import_node_path31.default.resolve(input);
-  try {
-    return await import_node_fs17.promises.realpath(resolved);
-  } catch {
-    return resolved;
-  }
-}
-async function writeAtomically(target, contents) {
-  await import_node_fs17.promises.mkdir(import_node_path31.default.dirname(target), { recursive: true });
-  const tmp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
-  const fd = await import_node_fs17.promises.open(tmp, "w");
-  try {
-    await fd.writeFile(contents, "utf8");
-    await fd.sync();
-  } finally {
-    await fd.close();
-  }
-  await import_node_fs17.promises.rename(tmp, target);
-}
-async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS) {
-  const deadline = Date.now() + timeoutMs;
-  await import_node_fs17.promises.mkdir(import_node_path31.default.dirname(lockPath), { recursive: true });
-  while (true) {
-    try {
-      const fd = await import_node_fs17.promises.open(lockPath, "wx");
-      await fd.close();
-      return;
-    } catch (err) {
-      const code = err.code;
-      if (code !== "EEXIST") throw err;
-      if (Date.now() >= deadline) {
-        throw new Error(
-          `neat registry: timed out after ${timeoutMs}ms waiting for ${lockPath}. Another neat process is holding the lock; if no such process exists, remove the file by hand.`
-        );
-      }
-      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
-    }
-  }
-}
-async function releaseLock(lockPath) {
-  await import_node_fs17.promises.unlink(lockPath).catch(() => {
-  });
-}
-async function withLock(fn) {
-  const lock = registryLockPath();
-  await acquireLock(lock);
-  try {
-    return await fn();
-  } finally {
-    await releaseLock(lock);
-  }
-}
-async function readRegistry() {
-  const file = registryPath();
-  let raw;
-  try {
-    raw = await import_node_fs17.promises.readFile(file, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return { version: 1, projects: [] };
-    }
-    throw err;
-  }
-  const parsed = JSON.parse(raw);
-  return import_types19.RegistryFileSchema.parse(parsed);
-}
-async function writeRegistry(reg) {
-  const validated = import_types19.RegistryFileSchema.parse(reg);
-  await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + "\n");
-}
-var ProjectNameCollisionError = class extends Error {
-  projectName;
-  constructor(name) {
-    super(`neat registry: a project named "${name}" is already registered`);
-    this.name = "ProjectNameCollisionError";
-    this.projectName = name;
-  }
-};
-async function addProject(opts) {
-  const resolvedPath = await normalizeProjectPath(opts.path);
-  return withLock(async () => {
-    const reg = await readRegistry();
-    const byName = reg.projects.find((p) => p.name === opts.name);
-    const byPath = reg.projects.find((p) => p.path === resolvedPath);
-    if (byName && byName.path !== resolvedPath) {
-      throw new ProjectNameCollisionError(opts.name);
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    if (byName && byName.path === resolvedPath) {
-      byName.lastSeenAt = now;
-      if (opts.languages) byName.languages = opts.languages;
-      if (opts.status) byName.status = opts.status;
-      await writeRegistry(reg);
-      return byName;
-    }
-    if (byPath && byPath.name !== opts.name) {
-      throw new ProjectNameCollisionError(byPath.name);
-    }
-    const entry = {
-      name: opts.name,
-      path: resolvedPath,
-      registeredAt: now,
-      languages: opts.languages ?? [],
-      status: opts.status ?? "active"
-    };
-    reg.projects.push(entry);
-    await writeRegistry(reg);
-    return entry;
-  });
-}
-async function getProject(name) {
-  const reg = await readRegistry();
-  return reg.projects.find((p) => p.name === name);
-}
-async function listProjects() {
-  const reg = await readRegistry();
-  return reg.projects;
-}
-async function setStatus(name, status2) {
-  return withLock(async () => {
-    const reg = await readRegistry();
-    const entry = reg.projects.find((p) => p.name === name);
-    if (!entry) throw new Error(`neat registry: no project named "${name}"`);
-    entry.status = status2;
-    await writeRegistry(reg);
-    return entry;
-  });
-}
-async function touchLastSeen(name, at = (/* @__PURE__ */ new Date()).toISOString()) {
-  await withLock(async () => {
-    const reg = await readRegistry();
-    const entry = reg.projects.find((p) => p.name === name);
-    if (!entry) return;
-    entry.lastSeenAt = at;
-    await writeRegistry(reg);
-  });
-}
-async function removeProject(name) {
-  return withLock(async () => {
-    const reg = await readRegistry();
-    const idx = reg.projects.findIndex((p) => p.name === name);
-    if (idx < 0) return void 0;
-    const [removed] = reg.projects.splice(idx, 1);
-    await writeRegistry(reg);
-    return removed;
-  });
-}
-
-// src/daemon.ts
 function neatHomeFor(opts) {
   if (opts.neatHome && opts.neatHome.length > 0) return import_node_path32.default.resolve(opts.neatHome);
   const env = process.env.NEAT_HOME;