@neat.is/mcp 0.5.2 → 0.5.3

package/dist/index.cjs

@@ -49,12 +49,42 @@ function resolveBaseUrl(env = process.env, cwd = process.cwd()) {
 }
 
 // src/client.ts
-function createHttpClient(baseUrl2, bearerToken) {
+var DEFAULT_TIMEOUT_MS = 3e4;
+function resolveTimeoutMs(explicit) {
+  if (typeof explicit === "number" && explicit > 0) return explicit;
+  const fromEnv = Number(process.env.NEAT_CORE_TIMEOUT_MS);
+  if (Number.isFinite(fromEnv) && fromEnv > 0) return fromEnv;
+  return DEFAULT_TIMEOUT_MS;
+}
+function isTimeoutAbort(err) {
+  const name = err?.name;
+  return name === "TimeoutError" || name === "AbortError";
+}
+async function fetchWithTimeout(url, init, timeoutMs, method, path) {
+  try {
+    return await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+  } catch (err) {
+    if (isTimeoutAbort(err)) {
+      throw new RequestTimeoutError(
+        `Timed out after ${timeoutMs}ms waiting for neat-core on ${method} ${path} \u2014 the daemon may be starting up, busy, or wedged. Confirm it is reachable (curl its /health endpoint) or raise NEAT_CORE_TIMEOUT_MS.`
+      );
+    }
+    throw err;
+  }
+}
+function createHttpClient(baseUrl2, bearerToken, timeoutMs) {
   const root = baseUrl2.replace(/\/$/, "");
+  const deadline = resolveTimeoutMs(timeoutMs);
   const authHeader = bearerToken && bearerToken.length > 0 ? { authorization: `Bearer ${bearerToken}` } : {};
   return {
     async get(path) {
-      const res = await fetch(`${root}${path}`, { headers: { ...authHeader } });
+      const res = await fetchWithTimeout(
+        `${root}${path}`,
+        { headers: { ...authHeader } },
+        deadline,
+        "GET",
+        path
+      );
       if (!res.ok) {
         const body = await res.text().catch(() => "");
         throw new HttpError(res.status, `${res.status} ${res.statusText} on GET ${path}: ${body}`);
@@ -62,11 +92,17 @@ function createHttpClient(baseUrl2, bearerToken) {
       return await res.json();
     },
     async post(path, body) {
-      const res = await fetch(`${root}${path}`, {
-        method: "POST",
-        headers: { "content-type": "application/json", ...authHeader },
-        body: JSON.stringify(body)
-      });
+      const res = await fetchWithTimeout(
+        `${root}${path}`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json", ...authHeader },
+          body: JSON.stringify(body)
+        },
+        deadline,
+        "POST",
+        path
+      );
       if (!res.ok) {
         const text = await res.text().catch(() => "");
         throw new HttpError(res.status, `${res.status} ${res.statusText} on POST ${path}: ${text}`);
@@ -83,6 +119,12 @@ var HttpError = class extends Error {
   }
   status;
 };
+var RequestTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RequestTimeoutError";
+  }
+};
 
 // src/resources.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
@@ -953,10 +995,19 @@ var projectFor = (input) => input.project ?? defaultProject;
 var projectField = import_zod.z.string().optional().describe(
   "Project name when the core hosts more than one (set NEAT_PROJECTS=...). Omit to use the default project."
 );
-var server = new import_mcp2.McpServer({
-  name: "neat",
-  version: "0.1.0"
-});
+var serverInstructions = [
+  "NEAT serves a fused semantic graph of one software system \u2014 static code (EXTRACTED) and live runtime behavior (OBSERVED) in a single model \u2014 for the one project this daemon owns. Every tool answers from that graph.",
+  "A result is a graph fact, not a live call to the underlying system. Each edge and result carries a provenance \u2014 OBSERVED (seen via OTel), INFERRED (stitched, ~0.6 confidence), EXTRACTED (from source/config), STALE (was observed, gone quiet) \u2014 plus a confidence. Trust a claim by its provenance.",
+  "Some OBSERVED data is pulled by connectors from a provider that runs its own telemetry (Supabase, Railway, Firebase, Cloudflare). That is NEAT's own view of the provider, keyed on the provider node (an InfraNode carries `provider`; a service/file carries `platform`). If you also have that provider's own MCP server, NEAT is not it and does not replace it \u2014 NEAT tells you how the graph relates, the provider server acts on the live system.",
+  "Reach for NEAT before grepping source for architecture-level questions: dependencies, runtime traffic, recent failures, blast radius, divergence between declared and observed. If a query comes back empty, confirm the daemon is up before falling back to reading files."
+].join("\n\n");
+var server = new import_mcp2.McpServer(
+  {
+    name: "neat",
+    version: "0.1.0"
+  },
+  { instructions: serverInstructions }
+);
 var registerTool = (name, description, paramsSchema, cb) => server.tool(name, description, paramsSchema, cb);
 registerTool(
   "get_root_cause",