@neat.is/core 0.6.2-dev.20260723 → 0.6.2

package/dist/cli.cjs

@@ -706,6 +706,7 @@ __export(cli_exports, {
 module.exports = __toCommonJS(cli_exports);
 init_cjs_shims();
 var import_node_path63 = __toESM(require("path"), 1);
+var import_node_os6 = __toESM(require("os"), 1);
 var import_node_fs41 = require("fs");
 
 // src/banner.ts
@@ -5689,7 +5690,7 @@ function keywordArrayStrings(argsNode, key) {
   }
   return [];
 }
-function collectApiRouterPrefixes(root) {
+function collectPythonRouterPrefixes(root) {
   const prefixes = /* @__PURE__ */ new Map();
   walk(root, (node) => {
     if (node.type !== "assignment") return;
@@ -5698,7 +5699,8 @@ function collectApiRouterPrefixes(root) {
     const fn = right.childForFieldName("function");
     if (!fn) return;
     const ctor = fn.type === "attribute" ? fn.childForFieldName("attribute")?.text : fn.text;
-    if (ctor !== "APIRouter") return;
+    const prefixKey = ctor === "APIRouter" ? "prefix" : ctor === "Blueprint" ? "url_prefix" : null;
+    if (!prefixKey) return;
     const left = node.childForFieldName("left");
     if (!left || left.type !== "identifier") return;
     const args = right.childForFieldName("arguments");
@@ -5706,7 +5708,7 @@ function collectApiRouterPrefixes(root) {
     for (let i = 0; i < args.namedChildCount; i++) {
       const arg = args.namedChild(i);
       if (arg?.type !== "keyword_argument") continue;
-      if (arg.childForFieldName("name")?.text !== "prefix") continue;
+      if (arg.childForFieldName("name")?.text !== prefixKey) continue;
       const val = arg.childForFieldName("value");
       const p = val ? pyStaticStringText(val) : null;
       if (p !== null) prefixes.set(left.text, p);
@@ -5714,9 +5716,9 @@ function collectApiRouterPrefixes(root) {
   });
   return prefixes;
 }
-function fastapiRoutesFromSource(source, parser) {
+function pythonRoutesFromSource(source, parser, framework) {
   const tree = parseSource2(parser, source);
-  const prefixes = collectApiRouterPrefixes(tree.rootNode);
+  const prefixes = collectPythonRouterPrefixes(tree.rootNode);
   const out = [];
   walk(tree.rootNode, (node) => {
     if (node.type !== "decorator") return;
@@ -5727,7 +5729,9 @@ function fastapiRoutesFromSource(source, parser) {
     const method = fn.childForFieldName("attribute")?.text?.toLowerCase();
     if (!method) return;
     const isVerb = FASTAPI_METHODS.has(method);
-    if (!isVerb && method !== "api_route") return;
+    const isFlaskRoute = method === "route";
+    const isApiRoute = method === "api_route";
+    if (!isVerb && !isFlaskRoute && !isApiRoute) return;
     const args = call.childForFieldName("arguments");
     const first = args?.namedChild(0);
     if (!first || first.type !== "string") return;
@@ -5738,17 +5742,41 @@ function fastapiRoutesFromSource(source, parser) {
     const pathTemplate = canonicalizeTemplate(prefix + rawPath);
     const line = node.startPosition.row + 1;
     if (isVerb) {
-      out.push({ method: method.toUpperCase(), pathTemplate, line, framework: "fastapi" });
+      out.push({ method: method.toUpperCase(), pathTemplate, line, framework });
       return;
     }
     const methods = keywordArrayStrings(args, "methods");
-    const list = methods.length > 0 ? methods : ["ALL"];
+    const list = methods.length > 0 ? methods : isFlaskRoute ? ["GET"] : ["ALL"];
     for (const m of list) {
+      out.push({ method: m === "ALL" ? "ALL" : m.toUpperCase(), pathTemplate, line, framework });
+    }
+  });
+  return out;
+}
+function djangoRoutesFromSource(source, parser) {
+  const tree = parseSource2(parser, source);
+  const out = [];
+  walk(tree.rootNode, (node) => {
+    if (node.type !== "assignment") return;
+    if (node.childForFieldName("left")?.text !== "urlpatterns") return;
+    const list = node.childForFieldName("right");
+    if (!list || list.type !== "list") return;
+    for (let i = 0; i < list.namedChildCount; i++) {
+      const el = list.namedChild(i);
+      if (el?.type !== "call") continue;
+      if (el.childForFieldName("function")?.text !== "path") continue;
+      const args = el.childForFieldName("arguments");
+      const first = args?.namedChild(0);
+      if (first?.type !== "string") continue;
+      const raw = pyStaticStringText(first);
+      if (raw === null) continue;
+      const second = args?.namedChild(1);
+      if (second?.type === "call" && second.childForFieldName("function")?.text === "include") continue;
       out.push({
-        method: m === "ALL" ? "ALL" : m.toUpperCase(),
-        pathTemplate,
-        line,
-        framework: "fastapi"
+        method: "ALL",
+        pathTemplate: canonicalizeTemplate(raw),
+        line: el.startPosition.row + 1,
+        framework: "django"
       });
     }
   });
@@ -5769,7 +5797,10 @@ async function addRoutes(graph, services) {
     const hasHono = deps["hono"] !== void 0;
     const hasNext = deps["next"] !== void 0;
     const hasFastapi = deps["fastapi"] !== void 0;
-    if (!hasExpress && !hasFastify && !hasHono && !hasNext && !hasFastapi) continue;
+    const hasFlask = deps["flask"] !== void 0;
+    const hasDjango = deps["django"] !== void 0;
+    if (!hasExpress && !hasFastify && !hasHono && !hasNext && !hasFastapi && !hasFlask && !hasDjango)
+      continue;
     const files = await loadSourceFiles(service.dir);
     for (const file of files) {
       if (isTestPath(file.path)) continue;
@@ -5780,7 +5811,8 @@ async function addRoutes(graph, services) {
       let routes;
       try {
         if (isPy) {
-          routes = hasFastapi ? fastapiRoutesFromSource(file.content, pyParser) : [];
+          routes = hasFastapi || hasFlask ? pythonRoutesFromSource(file.content, pyParser, hasFastapi ? "fastapi" : "flask") : [];
+          if (hasDjango) routes = routes.concat(djangoRoutesFromSource(file.content, pyParser));
         } else if (hasNext && (isNextAppRouteFile(relFile) || isNextPagesApiFile(relFile))) {
           routes = nextRoutesFromFile(file.content, relFile, jsParser);
         } else if (hasExpress || hasFastify || hasHono) {
@@ -9946,6 +9978,22 @@ function describeCredential(ref, env = process.env) {
 init_cjs_shims();
 var CONNECTOR_STALE_THRESHOLD_MS = 5 * 6e4;
 var records = /* @__PURE__ */ new Map();
+var MAX_ERROR_LEN = 200;
+function sanitizePollError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const collapsed = msg.replace(/\s+/g, " ").trim();
+  return collapsed.length > MAX_ERROR_LEN ? `${collapsed.slice(0, MAX_ERROR_LEN - 1)}\u2026` : collapsed;
+}
+function recordConnectorPoll(id, tick) {
+  const prev = records.get(id);
+  records.set(id, {
+    lastPollAt: tick.at,
+    lastOutcome: tick.outcome,
+    lastError: tick.outcome === "error" ? tick.error ?? null : null,
+    signalsLastPoll: tick.signalsLastPoll ?? 0,
+    lastOkAt: tick.outcome === "ok" ? tick.at : prev?.lastOkAt ?? null
+  });
+}
 function deriveState(rec, now, thresholdMs) {
   if (rec.lastOutcome === "error") return "error";
   const okAt = rec.lastOkAt ? Date.parse(rec.lastOkAt) : NaN;
@@ -10736,19 +10784,128 @@ async function buildApi(opts) {
 init_auth();
 init_otel();
 
-// src/daemon.ts
+// src/connectors/registry.ts
 init_cjs_shims();
-var import_node_fs33 = require("fs");
-var import_node_path54 = __toESM(require("path"), 1);
-var import_node_module = require("module");
-init_otel();
 
 // src/connectors/index.ts
 init_cjs_shims();
 var import_types37 = require("@neat.is/types");
-
-// src/connectors/registry.ts
-init_cjs_shims();
+var NO_ENV = "unknown";
+function staticCallSiteFor(graph, serviceName, targetNodeId) {
+  if (!graph.hasNode(targetNodeId)) return void 0;
+  const sites = [];
+  for (const edgeId of graph.inboundEdges(targetNodeId)) {
+    const edge = graph.getEdgeAttributes(edgeId);
+    if (edge.provenance !== import_types37.Provenance.EXTRACTED) continue;
+    const parsed = (0, import_types37.parseFileId)(edge.source);
+    if (!parsed || parsed.service !== serviceName || !edge.evidence) continue;
+    const site = { relPath: edge.evidence.file };
+    if (edge.evidence.line !== void 0) site.line = edge.evidence.line;
+    sites.push(site);
+  }
+  return sites.length === 1 ? sites[0] : void 0;
+}
+function routeCallSiteFor(graph, targetNodeId) {
+  if (!graph.hasNode(targetNodeId)) return void 0;
+  const attrs = graph.getNodeAttributes(targetNodeId);
+  if (attrs.type !== import_types37.NodeType.RouteNode || !attrs.path) return void 0;
+  const site = { relPath: attrs.path };
+  if (attrs.line !== void 0) site.line = attrs.line;
+  return site;
+}
+async function runConnectorPoll(connector, ctx, graph, resolveTarget) {
+  const signals = await connector.poll(ctx);
+  let edgesCreated = 0;
+  let edgesUpdated = 0;
+  let unresolved = 0;
+  for (const signal of signals) {
+    const resolved = resolveTarget(signal, ctx);
+    if (!resolved) {
+      unresolved++;
+      continue;
+    }
+    if (resolved.ensureInfraNode) {
+      const { kind, name, provider } = resolved.ensureInfraNode;
+      ensureInfraNode(graph, kind, name, provider);
+    }
+    const serviceNodeId = ensureServiceNode(graph, resolved.serviceName, NO_ENV);
+    const callSite = signal.callSite ? { relPath: signal.callSite.file, line: signal.callSite.line } : routeCallSiteFor(graph, resolved.targetNodeId) ?? staticCallSiteFor(graph, resolved.serviceName, resolved.targetNodeId);
+    const sourceId = callSite ? ensureObservedFileNode(graph, resolved.serviceName, serviceNodeId, callSite) : serviceNodeId;
+    const evidence = callSite ? {
+      file: reconcileObservedRelPath(graph, resolved.serviceName, callSite.relPath),
+      line: callSite.line
+    } : void 0;
+    const calls = Math.trunc(signal.callCount);
+    if (!Number.isFinite(calls) || calls < 1) continue;
+    const errors = Number.isFinite(signal.errorCount) ? Math.min(Math.max(Math.trunc(signal.errorCount), 0), calls) : 0;
+    let created = false;
+    let ok = true;
+    for (let i = 0; i < calls; i++) {
+      const result = upsertObservedEdge(
+        graph,
+        resolved.edgeType,
+        sourceId,
+        resolved.targetNodeId,
+        signal.lastObservedIso,
+        i < errors,
+        evidence
+      );
+      if (!result) {
+        ok = false;
+        break;
+      }
+      if (i === 0) created = result.created;
+    }
+    if (!ok) {
+      unresolved++;
+      continue;
+    }
+    if (created) edgesCreated++;
+    else edgesUpdated++;
+  }
+  return { signalCount: signals.length, edgesCreated, edgesUpdated, unresolved };
+}
+var DEFAULT_POLL_INTERVAL_MS = 6e4;
+function startConnectorPollLoop(connector, ctx, graph, resolveTarget, options = {}) {
+  let stopped = false;
+  let since = ctx.since;
+  const intervalMs = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const connectorId = options.connectorId;
+  const onError = options.onError ?? ((err) => console.error(`[neatd] connector poll failed (${connector.provider})`, err));
+  const tick = () => {
+    if (stopped) return;
+    void (async () => {
+      const tickStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+      try {
+        const result = await runConnectorPoll(connector, { ...ctx, since }, graph, resolveTarget);
+        since = tickStartedAt;
+        if (connectorId) {
+          recordConnectorPoll(connectorId, {
+            outcome: "ok",
+            at: tickStartedAt,
+            signalsLastPoll: result.signalCount
+          });
+        }
+      } catch (err) {
+        onError(err);
+        if (connectorId) {
+          recordConnectorPoll(connectorId, {
+            outcome: "error",
+            at: tickStartedAt,
+            error: sanitizePollError(err)
+          });
+        }
+      }
+    })();
+  };
+  tick();
+  const interval = setInterval(tick, intervalMs);
+  if (typeof interval.unref === "function") interval.unref();
+  return () => {
+    stopped = true;
+    clearInterval(interval);
+  };
+}
 
 // src/connectors/junction.ts
 init_cjs_shims();
@@ -11357,17 +11514,22 @@ function readRailwayToken(credentials) {
   }
   return token;
 }
-function projectAccessTokenHeader(token) {
-  return { "Project-Access-Token": token };
+var RAILWAY_AUTH_STYLES = ["bearer", "project-access-token"];
+function railwayAuthHeader(style, token) {
+  return style === "bearer" ? { Authorization: `Bearer ${token}` } : { "Project-Access-Token": token };
 }
-async function railwayGraphQL(apiUrl, token, query, variables, accountKey, fetchImpl) {
+var resolvedRailwayAuthStyle = /* @__PURE__ */ new Map();
+function isRailwayNotAuthorized(err) {
+  return err instanceof Error && /not authorized/i.test(err.message);
+}
+async function railwayGraphQLOnce(apiUrl, style, token, query, variables, accountKey, fetchImpl) {
   const res = await junctionFetch(
     apiUrl,
     {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        ...projectAccessTokenHeader(token)
+        ...railwayAuthHeader(style, token)
       },
       body: JSON.stringify({ query, variables })
     },
@@ -11383,6 +11545,26 @@ async function railwayGraphQL(apiUrl, token, query, variables, accountKey, fetch
   if (!body.data) throw new Error("Railway GraphQL response carried no data");
   return body.data;
 }
+async function railwayGraphQL(apiUrl, token, query, variables, accountKey, fetchImpl) {
+  const known = resolvedRailwayAuthStyle.get(token);
+  const styles = known ? [known] : RAILWAY_AUTH_STYLES;
+  let lastNotAuthorized;
+  for (let i = 0; i < styles.length; i++) {
+    const style = styles[i];
+    try {
+      const data = await railwayGraphQLOnce(apiUrl, style, token, query, variables, accountKey, fetchImpl);
+      resolvedRailwayAuthStyle.set(token, style);
+      return data;
+    } catch (err) {
+      if (isRailwayNotAuthorized(err) && i < styles.length - 1) {
+        lastNotAuthorized = err;
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastNotAuthorized ?? new Error("Railway GraphQL: no auth style resolved");
+}
 var HTTP_LOGS_QUERY = `
   query HttpLogs($deploymentId: String!, $startDate: String, $endDate: String, $limit: Int) {
     httpLogs(deploymentId: $deploymentId, startDate: $startDate, endDate: $endDate, limit: $limit) {
@@ -12431,6 +12613,49 @@ function resolveEntryCredentials(dispatch, entry2, env) {
   }
   return { ok: true, credentials };
 }
+function buildRegistration(entry2, graph, env = process.env) {
+  const dispatch = PROVIDER_DISPATCH[entry2.provider];
+  if (!dispatch) {
+    if (isPushProvider(entry2.provider)) {
+      return {
+        ok: false,
+        push: true,
+        reason: `push provider "${entry2.provider}" ingests via the OTLP receiver \u2014 nothing to poll`
+      };
+    }
+    return { ok: false, reason: `unknown provider "${entry2.provider}"` };
+  }
+  const creds = resolveEntryCredentials(dispatch, entry2, env);
+  if (!creds.ok) return { ok: false, reason: creds.reason };
+  const credentials = creds.credentials;
+  const options = entry2.options ?? {};
+  const missingOpts = dispatch.requiredOptionFields.filter((k) => !(k in options));
+  if (missingOpts.length > 0) {
+    return {
+      ok: false,
+      reason: `options missing required field(s): ${missingOpts.join(", ")}`
+    };
+  }
+  let built;
+  try {
+    built = dispatch.build(graph, options);
+  } catch (err) {
+    return { ok: false, reason: err.message };
+  }
+  const intervalMs = typeof options.intervalMs === "number" ? options.intervalMs : void 0;
+  return {
+    ok: true,
+    registration: {
+      // Carry the entry id so the daemon can key this connector's poll-status
+      // records to it (ADR-136).
+      id: entry2.id,
+      connector: built.connector,
+      credentials,
+      resolveTarget: built.resolveTarget,
+      ...intervalMs !== void 0 ? { intervalMs } : {}
+    }
+  };
+}
 async function validateConnectorEntry(entry2, env = process.env, fetchImpl) {
   const dispatch = PROVIDER_DISPATCH[entry2.provider] ?? PUSH_PROVIDER_DISPATCH[entry2.provider];
   if (!dispatch) {
@@ -12456,6 +12681,48 @@ async function validateConnectorEntry(entry2, env = process.env, fetchImpl) {
   });
   return result.ok ? { status: "ok" } : { status: "rejected", reason: result.reason };
 }
+async function loadConnectorRegistrations(input) {
+  const { project, graph, home, env = process.env, onSkip } = input;
+  let connectors;
+  try {
+    connectors = (await readConnectorsConfig(home)).connectors;
+  } catch (err) {
+    onSkip?.(
+      { id: "(file)", provider: "(all)", credential: "" },
+      `connectors.json unreadable \u2014 ${err.message}`
+    );
+    return [];
+  }
+  const registrations = [];
+  for (const entry2 of connectors) {
+    if (!connectorMatchesProject(entry2, project)) continue;
+    const result = buildRegistration(entry2, graph, env);
+    if (result.ok) registrations.push(result.registration);
+    else if (!result.push) onSkip?.(entry2, result.reason);
+  }
+  return registrations;
+}
+async function startConnectorPolling(input) {
+  const fileConnectors = input.home ? await loadConnectorRegistrations({
+    project: input.project,
+    graph: input.graph,
+    home: input.home,
+    ...input.onSkip ? { onSkip: input.onSkip } : {}
+  }) : [];
+  const all = [...input.extra ?? [], ...fileConnectors];
+  const stopFns = all.map(
+    (registration) => startConnectorPollLoop(
+      registration.connector,
+      { projectDir: input.projectDir, credentials: registration.credentials },
+      input.graph,
+      registration.resolveTarget,
+      { intervalMs: registration.intervalMs, connectorId: registration.id }
+    )
+  );
+  return () => {
+    for (const stop of stopFns) stop();
+  };
+}
 function resolvePushEntry(entry2, env) {
   const dispatch = PUSH_PROVIDER_DISPATCH[entry2.provider];
   if (!dispatch) {
@@ -12506,6 +12773,11 @@ async function deprovisionConnector(entry2, env = process.env, fetchImpl) {
 }
 
 // src/daemon.ts
+init_cjs_shims();
+var import_node_fs33 = require("fs");
+var import_node_path54 = __toESM(require("path"), 1);
+var import_node_module = require("module");
+init_otel();
 init_auth();
 
 // src/unrouted.ts
@@ -13120,6 +13392,15 @@ async function startWatch(graph, opts) {
     project: projectName,
     onPolicyTrigger
   });
+  const stopConnectors = await startConnectorPolling({
+    project: projectName,
+    graph,
+    projectDir: opts.scanPath,
+    ...opts.neatHome ? { home: opts.neatHome } : {},
+    onSkip: (skipped, reason) => console.warn(
+      `neat watch: connector "${skipped.id}" (${skipped.provider}) skipped for project "${projectName}" \u2014 ${reason}`
+    )
+  });
   const auth = readAuthEnv();
   const host = opts.host ?? (auth.authToken ? "0.0.0.0" : "127.0.0.1");
   assertBindAuthority(host, auth.authToken);
@@ -13305,6 +13586,7 @@ async function startWatch(graph, opts) {
       }
     }
     await watcher.close();
+    stopConnectors();
     stopStaleness();
     stopPersist();
     detachEventBus();
@@ -18247,6 +18529,9 @@ async function main() {
       errorsPath,
       staleEventsPath,
       project,
+      // Resolve NEAT_HOME so a `neat watch` picks up connectors added to
+      // ~/.neat/connectors.json (#871). Same resolution the rest of the CLI uses.
+      neatHome: process.env.NEAT_HOME ? import_node_path63.default.resolve(process.env.NEAT_HOME) : import_node_path63.default.join(import_node_os6.default.homedir(), ".neat"),
       ...embeddingsCachePath ? { embeddingsCachePath } : {},
       host: process.env.HOST ?? "0.0.0.0",
       port: Number(process.env.PORT ?? 8080),