@neat.is/mcp 0.7.10 → 0.8.0

package/dist/index.js

@@ -424,6 +424,14 @@ async function getRootCause(client2, input) {
     if (result.fixRecommendation) {
       blockLines.push(`Recommended fix: ${result.fixRecommendation}`);
     }
+    if (result.candidates && result.candidates.length > 0) {
+      blockLines.push("", "Candidates (ranked, most likely cause first):");
+      for (const c of result.candidates) {
+        blockLines.push(
+          `  \u2022 ${c.node} \u2014 ${c.classification} (confidence ${c.confidence.toFixed(2)}): ${c.reason}`
+        );
+      }
+    }
     return formatToolResponse({
       summary,
       block: blockLines.join("\n"),
@@ -558,6 +566,50 @@ function formatDuration(ms) {
   if (h < 48) return `${h}h`;
   return `${Math.round(h / 24)}d`;
 }
+async function expandNode(client2, input) {
+  const path = projectPath(
+    input.project,
+    `/graph/expand/${encodeURIComponent(input.nodeId)}?direction=${input.direction}`
+  );
+  return withMissingNodeFallback(async () => {
+    const result = await client2.get(path);
+    const dirWord = input.direction === "up" ? "callers/dependents (up)" : "callees/dependencies (down)";
+    const summary = `${result.node.id} is ${result.node.classification}. ${result.neighbours.length} ${dirWord}.`;
+    const blockLines = result.neighbours.map(
+      (n) => `  \u2022 ${n.node} \u2014 ${n.classification} via ${n.edgeType} (${n.provenance})`
+    );
+    return formatToolResponse({
+      summary,
+      block: blockLines.length ? blockLines.join("\n") : "(no runtime neighbours in this direction)"
+    });
+  }, `Node ${input.nodeId} not found in the graph.`);
+}
+async function relate(client2, input) {
+  const qs = input.maxDepth !== void 0 ? `&maxDepth=${input.maxDepth}` : "";
+  const path = projectPath(
+    input.project,
+    `/graph/relate?a=${encodeURIComponent(input.a)}&b=${encodeURIComponent(input.b)}${qs}`
+  );
+  try {
+    const result = await client2.get(path);
+    if (!result.related) {
+      return formatEmptyResponse(
+        `${input.a} and ${input.b} are not related \u2014 ${result.note ?? "no path found"}.`
+      );
+    }
+    const arrow = result.direction === "a->b" ? `${input.a} \u2192 ${input.b}` : `${input.b} \u2192 ${input.a}`;
+    const carries = result.paths[0]?.carriesSignal ? "and the path carries the failure end to end" : "but the path carries no failure signal";
+    const gap = result.grainGap ? " (grain gap \u2014 only a coarser link is in evidence)" : "";
+    const summary = `${arrow}: a path exists ${carries}${gap}.`;
+    const blockLines = result.paths.map(
+      (p) => `  ${p.nodes.join(" \u2192 ")}  [${p.edgeTypes.join(", ")}]  carriesSignal=${p.carriesSignal}`
+    );
+    return formatToolResponse({ summary, block: blockLines.join("\n") });
+  } catch (err) {
+    if (err instanceof ProjectNotFoundError) return formatErrorResponse(err.message);
+    return formatErrorResponse(`Error talking to neat-core: ${err.message}`);
+  }
+}
 async function getIncidentHistory(client2, input) {
   return withMissingNodeFallback(async () => {
     const body = await client2.get(
@@ -1081,6 +1133,27 @@ registerTool(
   },
   async (input) => getObservedDependencies(client, { ...input, project: projectFor(input) })
 );
+registerTool(
+  "expand",
+  'Take one navigation step from a node and classify the neighbourhood (ADR-189). direction "up" walks to callers/dependents (who calls this), "down" walks to callees/dependencies (what this calls). Each neighbour comes back classified primary-failure / symptom-only / unrelated. Use this to navigate a failure one hop at a time instead of trusting a single verdict \u2014 a symptom-only node is a downstream victim, so walk "up" from it toward the real cause.',
+  {
+    nodeId: z.string().describe("Graph node id to step from"),
+    direction: z.enum(["up", "down"]).describe("up = callers/dependents (toward the cause), down = callees/dependencies"),
+    project: projectField
+  },
+  async (input) => expandNode(client, { ...input, project: projectFor(input) })
+);
+registerTool(
+  "relate",
+  'Confirm whether two nodes are connected, which way, and whether the connecting path carries the failure (ADR-189). Returns the direction (a\u2192b or b\u2192a), the path with per-hop provenance, and carriesSignal \u2014 whether errors/latency run end to end, which turns "a path exists" into "a is actually causing b". No path within the depth bound returns "no path within N hops", never a false "unrelated".',
+  {
+    a: z.string().describe("First node id (the hypothesised cause)"),
+    b: z.string().describe("Second node id (the hypothesised symptom)"),
+    maxDepth: z.number().int().min(1).max(10).optional().describe("Max path length to search (default 5)"),
+    project: projectField
+  },
+  async (input) => relate(client, { ...input, project: projectFor(input) })
+);
 registerTool(
   "get_incident_history",
   "Return recent OTel error events recorded against a node, most recent first.",