@neat.is/core 0.5.4-dev.20260721 → 0.6.1

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   routeSpanToProject,
   startDaemon
-} from "./chunk-VR73QNJD.js";
+} from "./chunk-3YUNROLT.js";
 import {
   ProjectNameCollisionError,
   addProject,
@@ -37,15 +37,15 @@ import {
   thresholdForEdgeType,
   touchLastSeen,
   writeAtomically
-} from "./chunk-PEFX3DBR.js";
+} from "./chunk-7C6ZULNU.js";
 import {
   startOtelGrpcReceiver
-} from "./chunk-4RU3AAOI.js";
+} from "./chunk-MVINCLQM.js";
 import {
   buildOtelReceiver,
   logSpanHandler,
   parseOtlpRequest
-} from "./chunk-I4NZ7PSN.js";
+} from "./chunk-BZ3AJVAC.js";
 export {
   ProjectNameCollisionError,
   addProject,

package/dist/neatd.cjs

@@ -342,6 +342,11 @@ function pickEnv(spanAttrs, resourceAttrs) {
   }
   return ENV_FALLBACK;
 }
+function normalizeDbSystem(attrs) {
+  const raw = attrs["db.system"];
+  if (typeof raw !== "string") return void 0;
+  return raw === "mongoose" ? "mongodb" : raw;
+}
 function messagingDestinationOf(attrs) {
   for (const key of ["messaging.destination.name", "messaging.destination"]) {
     const v = attrs[key];
@@ -396,7 +401,7 @@ function parseOtlpRequest(body) {
           durationNanos: durationNanos(span.startTimeUnixNano, span.endTimeUnixNano),
           env: pickEnv(attrs, resourceAttrs),
           attributes: attrs,
-          dbSystem: typeof attrs["db.system"] === "string" ? attrs["db.system"] : void 0,
+          dbSystem: normalizeDbSystem(attrs),
           dbName: typeof attrs["db.name"] === "string" ? attrs["db.name"] : void 0,
           dbCollection: typeof attrs["db.collection.name"] === "string" ? attrs["db.collection.name"] : typeof attrs["db.mongodb.collection"] === "string" ? attrs["db.mongodb.collection"] : void 0,
           messagingSystem: typeof attrs["messaging.system"] === "string" ? attrs["messaging.system"] : void 0,
@@ -5300,6 +5305,7 @@ init_cjs_shims();
 var import_node_path22 = __toESM(require("path"), 1);
 var import_tree_sitter2 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript2 = __toESM(require("tree-sitter-javascript"), 1);
+var import_tree_sitter_python2 = __toESM(require("tree-sitter-python"), 1);
 var import_types11 = require("@neat.is/types");
 var PARSE_CHUNK2 = 16384;
 function parseSource2(parser, source) {
@@ -5312,6 +5318,11 @@ function makeJsParser2() {
   p.setLanguage(import_tree_sitter_javascript2.default);
   return p;
 }
+function makePyParser2() {
+  const p = new import_tree_sitter2.default();
+  p.setLanguage(import_tree_sitter_python2.default);
+  return p;
+}
 var ROUTER_METHODS = /* @__PURE__ */ new Set([
   "get",
   "post",
@@ -5324,6 +5335,7 @@ var ROUTER_METHODS = /* @__PURE__ */ new Set([
 ]);
 var NEXT_APP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var JS_ROUTE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"]);
+var FASTAPI_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "options", "head", "trace"]);
 function canonicalizeTemplate(raw) {
   let p = raw.split("?")[0].split("#")[0];
   if (!p.startsWith("/")) p = "/" + p;
@@ -5551,8 +5563,102 @@ function nextRoutesFromFile(source, relFile, parser) {
   }
   return [];
 }
+function pyStaticStringText(node) {
+  if (node.type !== "string") return null;
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child?.type === "interpolation") return null;
+    if (child?.type === "string_content") return child.text;
+  }
+  return "";
+}
+function keywordArrayStrings(argsNode, key) {
+  for (let i = 0; i < argsNode.namedChildCount; i++) {
+    const arg = argsNode.namedChild(i);
+    if (arg?.type !== "keyword_argument") continue;
+    if (arg.childForFieldName("name")?.text !== key) continue;
+    const val = arg.childForFieldName("value");
+    if (!val || val.type !== "list") return [];
+    const out = [];
+    for (let j = 0; j < val.namedChildCount; j++) {
+      const el = val.namedChild(j);
+      if (el?.type === "string") {
+        const s = pyStaticStringText(el);
+        if (s) out.push(s);
+      }
+    }
+    return out;
+  }
+  return [];
+}
+function collectApiRouterPrefixes(root) {
+  const prefixes = /* @__PURE__ */ new Map();
+  walk(root, (node) => {
+    if (node.type !== "assignment") return;
+    const right = node.childForFieldName("right");
+    if (!right || right.type !== "call") return;
+    const fn = right.childForFieldName("function");
+    if (!fn) return;
+    const ctor = fn.type === "attribute" ? fn.childForFieldName("attribute")?.text : fn.text;
+    if (ctor !== "APIRouter") return;
+    const left = node.childForFieldName("left");
+    if (!left || left.type !== "identifier") return;
+    const args = right.childForFieldName("arguments");
+    if (!args) return;
+    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;
+      const val = arg.childForFieldName("value");
+      const p = val ? pyStaticStringText(val) : null;
+      if (p !== null) prefixes.set(left.text, p);
+    }
+  });
+  return prefixes;
+}
+function fastapiRoutesFromSource(source, parser) {
+  const tree = parseSource2(parser, source);
+  const prefixes = collectApiRouterPrefixes(tree.rootNode);
+  const out = [];
+  walk(tree.rootNode, (node) => {
+    if (node.type !== "decorator") return;
+    const call = node.namedChild(0);
+    if (!call || call.type !== "call") return;
+    const fn = call.childForFieldName("function");
+    if (!fn || fn.type !== "attribute") return;
+    const method = fn.childForFieldName("attribute")?.text?.toLowerCase();
+    if (!method) return;
+    const isVerb = FASTAPI_METHODS.has(method);
+    if (!isVerb && method !== "api_route") return;
+    const args = call.childForFieldName("arguments");
+    const first = args?.namedChild(0);
+    if (!first || first.type !== "string") return;
+    const rawPath = pyStaticStringText(first);
+    if (rawPath === null || !rawPath.startsWith("/")) return;
+    const obj = fn.childForFieldName("object")?.text;
+    const prefix = obj ? prefixes.get(obj) ?? "" : "";
+    const pathTemplate = canonicalizeTemplate(prefix + rawPath);
+    const line = node.startPosition.row + 1;
+    if (isVerb) {
+      out.push({ method: method.toUpperCase(), pathTemplate, line, framework: "fastapi" });
+      return;
+    }
+    const methods = keywordArrayStrings(args, "methods");
+    const list = methods.length > 0 ? methods : ["ALL"];
+    for (const m of list) {
+      out.push({
+        method: m === "ALL" ? "ALL" : m.toUpperCase(),
+        pathTemplate,
+        line,
+        framework: "fastapi"
+      });
+    }
+  });
+  return out;
+}
 async function addRoutes(graph, services) {
   const jsParser = makeJsParser2();
+  const pyParser = makePyParser2();
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
@@ -5564,15 +5670,20 @@ async function addRoutes(graph, services) {
     const hasFastify = deps["fastify"] !== void 0;
     const hasHono = deps["hono"] !== void 0;
     const hasNext = deps["next"] !== void 0;
-    if (!hasExpress && !hasFastify && !hasHono && !hasNext) continue;
+    const hasFastapi = deps["fastapi"] !== void 0;
+    if (!hasExpress && !hasFastify && !hasHono && !hasNext && !hasFastapi) continue;
     const files = await loadSourceFiles(service.dir);
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      if (!JS_ROUTE_EXTENSIONS.has(import_node_path22.default.extname(file.path))) continue;
+      const ext = import_node_path22.default.extname(file.path);
+      const isPy = ext === ".py";
+      if (!JS_ROUTE_EXTENSIONS.has(ext) && !isPy) continue;
       const relFile = toPosix2(import_node_path22.default.relative(service.dir, file.path));
       let routes;
       try {
-        if (hasNext && (isNextAppRouteFile(relFile) || isNextPagesApiFile(relFile))) {
+        if (isPy) {
+          routes = hasFastapi ? fastapiRoutesFromSource(file.content, pyParser) : [];
+        } else if (hasNext && (isNextAppRouteFile(relFile) || isNextPagesApiFile(relFile))) {
           routes = nextRoutesFromFile(file.content, relFile, jsParser);
         } else if (hasExpress || hasFastify || hasHono) {
           routes = serverRoutesFromSource(file.content, jsParser, hasExpress, hasFastify, hasHono);
@@ -5756,7 +5867,7 @@ init_cjs_shims();
 var import_node_path24 = __toESM(require("path"), 1);
 var import_tree_sitter3 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript3 = __toESM(require("tree-sitter-javascript"), 1);
-var import_tree_sitter_python2 = __toESM(require("tree-sitter-python"), 1);
+var import_tree_sitter_python3 = __toESM(require("tree-sitter-python"), 1);
 var import_types13 = require("@neat.is/types");
 var STRING_LITERAL_NODE_TYPES = /* @__PURE__ */ new Set(["string_fragment", "string_content"]);
 var JSX_EXTERNAL_LINK_TAGS = /* @__PURE__ */ new Set(["a", "Link", "NavLink", "ExternalLink", "Anchor"]);
@@ -5811,14 +5922,14 @@ function makeJsParser3() {
   p.setLanguage(import_tree_sitter_javascript3.default);
   return p;
 }
-function makePyParser2() {
+function makePyParser3() {
   const p = new import_tree_sitter3.default();
-  p.setLanguage(import_tree_sitter_python2.default);
+  p.setLanguage(import_tree_sitter_python3.default);
   return p;
 }
 async function addHttpCallEdges(graph, services) {
   const jsParser = makeJsParser3();
-  const pyParser = makePyParser2();
+  const pyParser = makePyParser3();
   const { knownHosts, hostToNodeId } = buildServiceHostIndex(services);
   let nodesAdded = 0;
   let edgesAdded = 0;
@@ -9774,6 +9885,42 @@ function registerRoutes(scope, ctx) {
       return reply.code(500).send({ error: err.message });
     }
   });
+  scope.get("/instrumentation", async (req2, reply) => {
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
+    if (!proj) return;
+    if (!proj.scanPath) {
+      return { engaged: null };
+    }
+    try {
+      const state = await describeProjectInstrumentation({ project: proj.name, scanPath: proj.scanPath });
+      const uninstrumented = await listUninstrumented({ project: proj.name, scanPath: proj.scanPath });
+      if (state.hookFiles.length === 0) {
+        return {
+          engaged: false,
+          diagnosis: {
+            reason: "No instrumented entry point found \u2014 NEAT hasn't written an OTel init hook for this project.",
+            fixCommand: "neat init",
+            detail: "Run `neat init` so NEAT writes the instrumentation hook next to your entry point, then run your app."
+          }
+        };
+      }
+      if (uninstrumented.length > 0) {
+        const names = uninstrumented.map((u) => u.library);
+        const more = names.length > 1 ? ` (and ${names.length - 1} more)` : "";
+        return {
+          engaged: false,
+          diagnosis: {
+            reason: `\`${names[0]}\`${more} isn't in the auto-instrumentation set, so spans from it won't reach the graph.`,
+            fixCommand: "neat extend",
+            detail: `Uninstrumented on your hot path: ${names.join(", ")}. Run \`neat extend\` to wire the missing instrumentation.`
+          }
+        };
+      }
+      return { engaged: true };
+    } catch {
+      return { engaged: null };
+    }
+  });
   scope.post("/extend/apply", async (req2, reply) => {
     const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
@@ -11636,15 +11783,21 @@ var PROVIDER_DISPATCH = {
         resolveTarget: createCloudflareResolveTarget(config, graph)
       };
     },
-    // GET /user/tokens/verify — Cloudflare's own purpose-built "is this API
-    // token live" endpoint. 200 on a valid token, 401 on an invalid one.
+    // GET /accounts/{accountId}/tokens/verify — the *account-scoped* token-verify
+    // endpoint. A Workers connector token is scoped to the account, and the
+    // user-level `GET /user/tokens/verify` returns 401 "Invalid API Token" for
+    // such a token even though it authenticates fine against the account's own
+    // resources (confirmed live). Probing the account-scoped verify endpoint —
+    // `accountId` is already required for this provider — returns 200
+    // `{status:"active"}` for a working token and 401 for a bad one, so a valid
+    // Workers token is no longer falsely rejected at `neat connector add`.
     validate({ credentials, options, fetchImpl }) {
       const cfg = options;
       const baseUrl = cfg.baseUrl ?? CLOUDFLARE_API_BASE_URL;
       return authProbe({
         provider: "cloudflare",
         accountKey: cfg.accountId ?? "validate",
-        url: `${baseUrl}/user/tokens/verify`,
+        url: `${baseUrl}/accounts/${cfg.accountId ?? ""}/tokens/verify`,
         token: String(credentials.apiToken ?? ""),
         ...fetchImpl ? { fetchImpl } : {}
       });