@flowatlas/cli 0.1.0

package/dist/chunks/chunk-XBCRZY5O.js

@@ -0,0 +1,859 @@
+import {
+  SCHEMA_VERSION,
+  loadConfig,
+  normalizePath,
+  openGraphDb,
+  pathAnswers
+} from "./chunk-QFF3SJXQ.js";
+
+// ../mcp/dist/server.js
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../mcp/dist/query/db.js
+import { existsSync, statSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+var DbHandle = class {
+  path;
+  config;
+  #repoDirs = /* @__PURE__ */ new Map();
+  #db;
+  #openedAt = 0;
+  constructor(options = {}) {
+    let dbPath = options.dbPath;
+    if (options.configPath !== void 0) {
+      const loaded = loadConfig(options.configPath);
+      this.config = loaded.config;
+      for (const service of loaded.config.services) {
+        this.#repoDirs.set(service.name, loaded.repoDir(service));
+      }
+      dbPath ??= resolve(loaded.outputDir, "graph.db");
+    }
+    if (dbPath === void 0)
+      throw new Error("neither a database nor a configuration was given");
+    this.path = isAbsolute(dbPath) ? dbPath : resolve(dbPath);
+  }
+  repoDir(service) {
+    return this.#repoDirs.get(service);
+  }
+  /**
+   * The database, or a sentence saying why there is none.
+   *
+   * A missing or stale file is an ordinary answer rather than a crash: the
+   * server stays up so the next question can be asked after a rebuild.
+   */
+  open() {
+    if (!existsSync(this.path)) {
+      this.#close();
+      return { error: `graph.db not found at ${this.path}; run flowatlas build` };
+    }
+    const modified = statSync(this.path).mtimeMs;
+    if (this.#db !== void 0 && modified !== this.#openedAt)
+      this.#close();
+    if (this.#db === void 0) {
+      try {
+        this.#db = openGraphDb(this.path, { readonly: true });
+        this.#openedAt = modified;
+      } catch (cause) {
+        return { error: `cannot read ${this.path}: ${cause instanceof Error ? cause.message : String(cause)}` };
+      }
+      const found = this.#db.schemaVersion();
+      if (found !== SCHEMA_VERSION) {
+        this.#close();
+        return { error: `schema-mismatch ${found} vs ${SCHEMA_VERSION}; run flowatlas build` };
+      }
+    }
+    return { db: this.#db };
+  }
+  #close() {
+    this.#db?.close();
+    this.#db = void 0;
+    this.#openedAt = 0;
+  }
+  close() {
+    this.#close();
+  }
+};
+
+// ../mcp/dist/tools/channels.js
+import { z as z2 } from "zod";
+
+// ../mcp/dist/query/types.js
+var truncationMessage = (count, exact) => `${exact ? "" : "\u2265"}${count} more nodes, increase depth or narrow scope`;
+
+// ../mcp/dist/query/detail.js
+var MAX_DETAIL = 2;
+var CLAMP_NOTE = "detail clamped to 2; use get_source";
+var clampDetail = (level) => level > MAX_DETAIL ? MAX_DETAIL : level;
+var projectDetail = (node, level) => {
+  const compact = { id: node.id, type: node.type, label: node.label };
+  if (level <= 0)
+    return compact;
+  if (node.file !== void 0) {
+    compact.loc = node.line === void 0 ? node.file : `${node.file}:${node.line}`;
+  }
+  if (node.repo !== "")
+    compact.service = node.repo;
+  if (node.kind !== void 0)
+    compact.kind = node.kind;
+  if (level <= 1)
+    return compact;
+  if (node.meta !== void 0 && Object.keys(node.meta).length > 0)
+    compact.meta = node.meta;
+  return compact;
+};
+var projectEdge = (edge, level) => {
+  const projected = { type: edge.type, confidence: edge.confidence };
+  if (level <= 0)
+    return projected;
+  if (edge.params !== void 0 && edge.params.length > 0)
+    projected.params = [...edge.params];
+  if (edge.returns !== void 0)
+    projected.returns = edge.returns;
+  return projected;
+};
+var truncate = (items, maxNodes) => {
+  if (items.length <= maxNodes)
+    return { items: [...items] };
+  return {
+    items: items.slice(0, maxNodes),
+    truncated: truncationMessage(items.length - maxNodes, true)
+  };
+};
+
+// ../mcp/dist/tools/common.js
+import { z } from "zod";
+var commonInput = {
+  detail: z.number().int().min(0).max(3).default(1).describe("0 id only, 1 adds location, 2 adds metadata, 3 is clamped to 2 (use get_source)"),
+  maxNodes: z.number().int().positive().max(2e3).default(150).describe("most nodes to return")
+};
+var respond = (value) => ({
+  content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
+});
+var bound = (input) => {
+  const asked = input.detail;
+  const detail = clampDetail(asked);
+  return {
+    detail,
+    maxNodes: input.maxNodes,
+    ...detail === asked ? {} : { note: CLAMP_NOTE }
+  };
+};
+var withDb = (handle, run) => {
+  const opened = handle.open();
+  if ("error" in opened)
+    return respond({ error: opened.error });
+  try {
+    return respond(run(opened.db));
+  } catch (cause) {
+    return respond({ error: cause instanceof Error ? cause.message : String(cause) });
+  }
+};
+
+// ../mcp/dist/tools/channels.js
+var channelId = (ref) => {
+  const trimmed = ref.trim();
+  return trimmed.startsWith("channel:") ? trimmed : `channel:${trimmed}`;
+};
+var registerChannels = (server, ctx) => {
+  const ends = (name, title, description, key) => {
+    server.registerTool(name, {
+      title,
+      description,
+      inputSchema: {
+        channel: z2.string().describe('a channel name, with or without the "channel:" prefix'),
+        ...commonInput
+      }
+    }, (input) => withDb(ctx.handle, (db) => {
+      const { detail, maxNodes, note } = bound(input);
+      const id = channelId(input.channel);
+      const channel = db.node(id);
+      if (channel === void 0)
+        return { error: `no channel named ${JSON.stringify(id)}` };
+      const edges = key === "producers" ? db.edgesTo(id, ["emits"]) : db.edgesFrom(id, ["consumes"]);
+      const nodes = edges.map((edge) => db.node(key === "producers" ? edge.from : edge.to)).filter((node) => node !== void 0).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+      const { items, truncated } = truncate(nodes, maxNodes);
+      return {
+        channel: projectDetail(channel, detail),
+        [key]: items.map((node) => projectDetail(node, detail)),
+        ...truncated === void 0 ? {} : { truncated },
+        ...note === void 0 ? {} : { note }
+      };
+    }));
+  };
+  ends("who_emits", "Who publishes to a channel", "Everything that publishes a message on a channel, across every repository.", "producers");
+  ends("who_consumes", "Who handles a channel", "Everything that handles messages from a channel, across every repository. An empty list means nothing handles it.", "consumers");
+};
+
+// ../mcp/dist/tools/contract.js
+import { z as z3 } from "zod";
+var isTypeId = (value) => value?.startsWith("type:") === true;
+var classify = (db, left, right) => {
+  const both = { ...left === void 0 ? {} : { left }, ...right === void 0 ? {} : { right } };
+  if (!isTypeId(left) || !isTypeId(right)) {
+    const missing = !isTypeId(left) ? "sending" : "receiving";
+    return {
+      status: "unchecked",
+      ...both,
+      note: `the ${missing} side declares no named type`
+    };
+  }
+  if (left === right) {
+    const shared = db.type(left)?.meta?.["sharedPackage"];
+    return typeof shared === "string" ? { status: "shared", ...both, note: `both sides import it from ${shared}` } : { status: "identical", ...both };
+  }
+  const a = db.type(left);
+  const b = db.type(right);
+  if (a === void 0 || b === void 0) {
+    return { status: "unchecked", ...both, note: "a type id on the edge is not in the registry" };
+  }
+  return {
+    status: a.structuralHash === b.structuralHash ? "identical" : "hash_differs",
+    ...both
+  };
+};
+var RANK = {
+  shared: 0,
+  identical: 1,
+  unchecked: 2,
+  hash_differs: 3
+};
+var worse = (a, b) => RANK[a] >= RANK[b] ? a : b;
+var sidesOf = (db, edge) => {
+  const handler = db.edgesFrom(edge.to, ["handles"])[0];
+  return {
+    request: classify(db, edge.params?.[0], handler?.params?.[0]),
+    response: classify(db, edge.returns, handler?.returns)
+  };
+};
+var parseEdgeRef = (ref) => {
+  const arrow = /^(.*?)\s*-([a-z_]+)->\s*(.*)$/.exec(ref.trim());
+  if (arrow !== null) {
+    return { from: (arrow[1] ?? "").trim(), type: arrow[2], to: (arrow[3] ?? "").trim() };
+  }
+  const plain = ref.split("->");
+  if (plain.length !== 2)
+    return void 0;
+  return { from: (plain[0] ?? "").trim(), to: (plain[1] ?? "").trim() };
+};
+var registerContract = (server, ctx) => {
+  server.registerTool("check_contract", {
+    title: "Check a contract",
+    description: 'Compare what one side of a cross-service edge sends against what the other side expects. Identifies an edge by its two ends, or by "from -http_calls-> to".',
+    inputSchema: {
+      edge: z3.string().optional().describe('"<from> -http_calls-> <to>"'),
+      from: z3.string().optional().describe("the calling node"),
+      to: z3.string().optional().describe("the node it reaches"),
+      ...commonInput
+    }
+  }, (input) => withDb(ctx.handle, (db) => {
+    const { note } = bound(input);
+    const parsed = input.edge !== void 0 ? parseEdgeRef(input.edge) : input.from !== void 0 && input.to !== void 0 ? { from: input.from, to: input.to } : void 0;
+    if (parsed === void 0) {
+      return { error: "give either edge, or both from and to" };
+    }
+    const candidates = db.edgesFrom(parsed.from).filter((edge2) => edge2.to === parsed.to).filter((edge2) => parsed.type === void 0 || edge2.type === parsed.type);
+    const edge = candidates[0];
+    if (edge === void 0) {
+      return { error: `no edge from ${parsed.from} to ${parsed.to}` };
+    }
+    const { request, response } = sidesOf(db, edge);
+    const status = worse(request.status, response.status);
+    const hash = (id) => id === void 0 ? void 0 : { id, structuralHash: db.type(id)?.structuralHash ?? "" };
+    const findings = ctx.contractChecker?.({
+      edge: { from: edge.from, to: edge.to, type: edge.type },
+      ...hash(response.left) === void 0 ? {} : { left: hash(response.left) },
+      ...hash(response.right) === void 0 ? {} : { right: hash(response.right) }
+    }) ?? [];
+    return {
+      edge: { from: edge.from, to: edge.to, type: edge.type, confidence: edge.confidence },
+      status,
+      request,
+      response,
+      findings,
+      ...note === void 0 ? {} : { note }
+    };
+  }));
+};
+
+// ../mcp/dist/tools/entries.js
+import { z as z4 } from "zod";
+var ENTRY_KINDS = [
+  "http",
+  "bot_command",
+  "bot_callback",
+  "bot_event",
+  "scene_step",
+  "event",
+  "rpc",
+  "cron"
+];
+var cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var inReadingOrder = (a, b) => cmp(a.repo, b.repo) || cmp(a.kind ?? "", b.kind ?? "") || cmp(a.label, b.label);
+var initialsOf = (text) => (text.match(/[A-Z]|(?<=[^A-Za-z0-9])[a-z]/g) ?? []).join("").toLowerCase();
+var rankMatches = (nodes, query) => {
+  const wanted = query.toLowerCase();
+  const ranked = [];
+  for (const node of nodes) {
+    const label = node.label.toLowerCase();
+    const id = node.id.toLowerCase();
+    if (label === wanted)
+      ranked.push({ node, score: 0 });
+    else if (label.startsWith(wanted))
+      ranked.push({ node, score: 1 });
+    else if (label.includes(wanted))
+      ranked.push({ node, score: 2 });
+    else if (initialsOf(node.label).includes(wanted))
+      ranked.push({ node, score: 3 });
+    else if (id.includes(wanted))
+      ranked.push({ node, score: 4 });
+  }
+  return ranked.sort((a, b) => a.score - b.score || a.node.label.length - b.node.label.length || cmp(a.node.id, b.node.id));
+};
+var registerEntries = (server, ctx) => {
+  server.registerTool("list_entries", {
+    title: "List entry points",
+    description: "Every way into the project: routes, bot commands, scheduled jobs, message handlers. Filter by service, kind or path prefix.",
+    inputSchema: {
+      service: z4.string().optional().describe("only this service"),
+      kind: z4.enum(ENTRY_KINDS).optional().describe("only this kind of entry"),
+      pathPrefix: z4.string().optional().describe("only routes whose path starts with this"),
+      ...commonInput
+    }
+  }, (input) => withDb(ctx.handle, (db) => {
+    const { detail, maxNodes, note } = bound(input);
+    const prefix = input.pathPrefix === void 0 ? void 0 : normalizePath(input.pathPrefix);
+    const all = db.nodesByType("entry", input.kind).filter((entry) => input.service === void 0 || entry.repo === input.service).filter((entry) => {
+      if (prefix === void 0)
+        return true;
+      const path = normalizePath(String(entry.meta?.["path"] ?? ""));
+      return path === prefix || path.startsWith(prefix === "/" ? "/" : `${prefix}/`);
+    }).sort(inReadingOrder);
+    const { items, truncated } = truncate(all, maxNodes);
+    return {
+      entries: items.map((entry) => projectDetail(entry, detail)),
+      total: all.length,
+      ...truncated === void 0 ? {} : { truncated },
+      ...note === void 0 ? {} : { note }
+    };
+  }));
+  server.registerTool("find_symbol", {
+    title: "Find a symbol",
+    description: 'Fuzzy search over every node by label and id. Accepts a substring or camel-case initials such as "ocs" for OrderCreationService.',
+    inputSchema: {
+      query: z4.string().describe("what to look for"),
+      types: z4.array(z4.string()).optional().describe("only these node types"),
+      service: z4.string().optional().describe("only this service"),
+      maxNodes: commonInput.maxNodes,
+      detail: commonInput.detail
+    }
+  }, (input) => withDb(ctx.handle, (db) => {
+    if (input.query.trim().length < 2)
+      return { matches: [], note: "query too short" };
+    const { detail, maxNodes, note } = bound(input);
+    const pool = db.search(input.query, {
+      ...input.types === void 0 ? {} : { types: input.types },
+      limit: Math.max(maxNodes * 4, 200)
+    });
+    const wider = pool.length > 0 ? pool : db.nodesByType("method");
+    const ranked = rankMatches(wider.filter((node) => input.service === void 0 || node.repo === input.service), input.query);
+    const { items, truncated } = truncate(ranked, maxNodes);
+    return {
+      matches: items.map((match) => projectDetail(match.node, detail)),
+      ...truncated === void 0 ? {} : { truncated },
+      ...note === void 0 ? {} : { note }
+    };
+  }));
+};
+
+// ../mcp/dist/tools/flow.js
+import { z as z5 } from "zod";
+
+// ../mcp/dist/query/entry-ref.js
+var isResolved = (ref) => "id" in ref;
+var asRoute = (text) => {
+  const match = /^([A-Za-z]+)\s+(\/.*)$/.exec(text.trim());
+  if (match === null)
+    return void 0;
+  return { method: (match[1] ?? "").toUpperCase(), path: normalizePath(match[2] ?? "/") };
+};
+var asBotKey = (text) => {
+  const match = /^bot:(.+)$/.exec(text.trim());
+  return match === null ? void 0 : (match[1] ?? "").trim();
+};
+var byId = (nodes) => [...nodes].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+var resolveEntryRef = (db, ref) => {
+  const trimmed = ref.trim();
+  const exact = db.node(trimmed);
+  if (exact !== void 0)
+    return { id: exact.id, node: exact };
+  const entries = db.nodesByType("entry");
+  const route = asRoute(trimmed);
+  if (route !== void 0) {
+    const matches = entries.filter((entry) => entry.kind === "http" && String(entry.meta?.["method"] ?? "") === route.method && pathAnswers(String(entry.meta?.["path"] ?? ""), route.path));
+    if (matches.length === 1)
+      return { id: matches[0].id, node: matches[0] };
+    if (matches.length > 1)
+      return { candidates: byId(matches) };
+  }
+  const key = asBotKey(trimmed);
+  if (key !== void 0) {
+    const matches = entries.filter((entry) => String(entry.meta?.["key"] ?? entry.label) === key && entry.kind?.startsWith("bot_") === true);
+    if (matches.length === 1)
+      return { id: matches[0].id, node: matches[0] };
+    if (matches.length > 1)
+      return { candidates: byId(matches) };
+  }
+  const named = entries.filter((entry) => entry.label === trimmed);
+  if (named.length === 1)
+    return { id: named[0].id, node: named[0] };
+  return { candidates: byId(named) };
+};
+
+// ../mcp/dist/query/flow.js
+var FORWARD_EDGES = [
+  "handles",
+  "calls",
+  "queries",
+  "caches",
+  "emits",
+  "consumes",
+  "http_calls",
+  "hits",
+  "triggers",
+  "reads_config"
+];
+var GUARD_EDGE = "guarded_by";
+var REVERSE_EDGES = FORWARD_EDGES;
+var SCAN_FACTOR = 4;
+var orderOf = (edge) => {
+  const order = edge.meta?.["order"];
+  return typeof order === "number" ? order : Number.MAX_SAFE_INTEGER;
+};
+var inCallOrder = (a, b) => (a.line ?? Number.MAX_SAFE_INTEGER) - (b.line ?? Number.MAX_SAFE_INTEGER) || (a.to < b.to ? -1 : a.to > b.to ? 1 : 0);
+var guardsOf = (db, id, detail) => db.edgesFrom(id, [GUARD_EDGE]).sort((a, b) => orderOf(a) - orderOf(b)).map((edge, index) => {
+  const node = db.node(edge.to);
+  return {
+    id: edge.to,
+    label: node?.label ?? edge.to,
+    kind: String(edge.meta?.["kind"] ?? node?.kind ?? "guard"),
+    order: orderOf(edge) === Number.MAX_SAFE_INTEGER ? index : orderOf(edge),
+    ...detail >= 2 && node?.file !== void 0 ? { loc: `${node.file}:${node.line ?? 0}` } : {}
+  };
+});
+var missingNode = (id) => ({ id, type: "missing", label: id });
+var buildFlowTree = (db, entryId, options = {}) => {
+  const depth = options.depth ?? 8;
+  const maxNodes = options.maxNodes ?? 150;
+  const detail = options.detail ?? 1;
+  const start = db.node(entryId);
+  const root = {
+    node: start === void 0 ? missingNode(entryId) : projectDetail(start, detail),
+    children: []
+  };
+  const rootGuards = guardsOf(db, entryId, detail);
+  if (rootGuards.length > 0)
+    root.guards = rootGuards;
+  const unresolvedIds = /* @__PURE__ */ new Set();
+  if (db.unresolvedFor(entryId).length > 0)
+    unresolvedIds.add(entryId);
+  let used = 1;
+  let scanned = 0;
+  let overflow = 0;
+  const scanLimit = maxNodes * SCAN_FACTOR;
+  const queue = [{ flow: root, id: entryId, path: /* @__PURE__ */ new Set([entryId]), level: 0 }];
+  while (queue.length > 0) {
+    const item = queue.shift();
+    if (item.level >= depth)
+      continue;
+    for (const edge of db.edgesFrom(item.id, FORWARD_EDGES).sort(inCallOrder)) {
+      scanned += 1;
+      if (scanned > scanLimit) {
+        overflow += 1;
+        continue;
+      }
+      const room = item.flow !== void 0 && used < maxNodes;
+      if (!room)
+        overflow += 1;
+      if (item.path.has(edge.to)) {
+        if (room) {
+          used += 1;
+          item.flow?.children.push({
+            node: { id: edge.to, type: "ref", label: edge.to, ref: true },
+            edge: projectEdge(edge, detail),
+            children: []
+          });
+        }
+        continue;
+      }
+      const target = db.node(edge.to);
+      let child;
+      if (room) {
+        if (target === void 0)
+          unresolvedIds.add(edge.to);
+        else if (db.unresolvedFor(edge.to).length > 0)
+          unresolvedIds.add(edge.to);
+        child = {
+          node: target === void 0 ? missingNode(edge.to) : projectDetail(target, detail),
+          edge: projectEdge(edge, detail),
+          children: []
+        };
+        const guards = guardsOf(db, edge.to, detail);
+        if (guards.length > 0)
+          child.guards = guards;
+        used += 1;
+        item.flow?.children.push(child);
+      }
+      queue.push({
+        flow: child,
+        id: edge.to,
+        path: /* @__PURE__ */ new Set([...item.path, edge.to]),
+        level: item.level + 1
+      });
+    }
+  }
+  const result = { root, unresolvedOnPath: unresolvedIds.size };
+  if (overflow > 0)
+    result.truncated = truncationMessage(overflow, scanned <= scanLimit);
+  return result;
+};
+var flatten = (node) => [
+  node,
+  ...node.children.flatMap((child) => flatten(child))
+];
+
+// ../mcp/dist/tools/flow.js
+var registerFlow = (server, ctx) => {
+  server.registerTool("get_flow", {
+    title: "Trace an entry point",
+    description: "Follow one entry point through every repository it reaches: handlers, calls, queries, channels and the routes it calls in other services. Returns a nested tree in call order, with the guard chain on each entry.",
+    inputSchema: {
+      entry: z5.string().describe('an entry: "POST /orders", "bot:order_confirm", or a full entry id'),
+      depth: z5.number().int().positive().max(32).default(8).describe("how many hops to follow"),
+      ...commonInput
+    }
+  }, (input) => withDb(ctx.handle, (db) => {
+    const { detail, maxNodes, note } = bound(input);
+    const ref = resolveEntryRef(db, input.entry);
+    if (!isResolved(ref)) {
+      if (ref.candidates.length > 0) {
+        return { candidates: ref.candidates.map((node) => projectDetail(node, detail)) };
+      }
+      const suggestions = rankMatches(db.nodesByType("entry"), input.entry).slice(0, 5).map((match) => projectDetail(match.node, detail));
+      return { error: `no entry matches ${JSON.stringify(input.entry)}`, suggestions };
+    }
+    const flow = buildFlowTree(db, ref.id, { depth: input.depth, maxNodes, detail });
+    return {
+      root: flow.root,
+      unresolvedOnPath: flow.unresolvedOnPath,
+      ...flow.truncated === void 0 ? {} : { truncated: flow.truncated },
+      ...note === void 0 ? {} : { note }
+    };
+  }));
+};
+
+// ../mcp/dist/tools/reach.js
+import { z as z6 } from "zod";
+var findTarget = (db, symbol) => {
+  const exact = db.node(symbol.trim());
+  if (exact !== void 0)
+    return exact;
+  const ranked = rankMatches(db.search(symbol, { limit: 200 }), symbol);
+  if (ranked.length === 0)
+    return [];
+  const best = ranked[0];
+  const tied = ranked.filter((match) => match.score === best.score);
+  return tied.length === 1 ? best.node : tied.slice(0, 8).map((match) => match.node);
+};
+var callersOf = (db, id, depth, maxNodes, detail) => {
+  const roots = [];
+  const queue = [
+    { id, level: 0, into: roots, path: /* @__PURE__ */ new Set([id]) }
+  ];
+  let used = 0;
+  let overflow = 0;
+  while (queue.length > 0) {
+    const item = queue.shift();
+    if (item.level >= depth)
+      continue;
+    for (const edge of db.edgesTo(item.id, REVERSE_EDGES)) {
+      if (item.path.has(edge.from))
+        continue;
+      if (used >= maxNodes) {
+        overflow += 1;
+        continue;
+      }
+      const source = db.node(edge.from);
+      if (source === void 0)
+        continue;
+      const flow = {
+        node: projectDetail(source, detail),
+        edge: projectEdge(edge, detail),
+        children: []
+      };
+      used += 1;
+      item.into.push(flow);
+      queue.push({
+        id: edge.from,
+        level: item.level + 1,
+        into: flow.children,
+        path: /* @__PURE__ */ new Set([...item.path, edge.from])
+      });
+    }
+  }
+  return {
+    callers: roots,
+    ...overflow > 0 ? { truncated: truncationMessage(overflow, true) } : {}
+  };
+};
+var registerReach = (server, ctx) => {
+  server.registerTool("who_calls", {
+    title: "Who calls this",
+    description: "Everything that reaches a symbol, following calls backward across repositories: direct callers, the routes that handle them, and requests from other services.",
+    inputSchema: {
+      symbol: z6.string().describe("a node id, or a name close enough to identify one"),
+      depth: z6.number().int().positive().max(16).default(3).describe("how many hops back"),
+      ...commonInput
+    }
+  }, (input) => withDb(ctx.handle, (db) => {
+    const { detail, maxNodes, note } = bound(input);
+    const found = findTarget(db, input.symbol);
+    if (Array.isArray(found)) {
+      return found.length === 0 ? { error: `no symbol matches ${JSON.stringify(input.symbol)}` } : { candidates: found.map((node) => projectDetail(node, detail)) };
+    }
+    const { callers, truncated } = callersOf(db, found.id, input.depth, maxNodes, detail);
+    return {
+      target: projectDetail(found, detail),
+      callers,
+      ...truncated === void 0 ? {} : { truncated },
+      ...note === void 0 ? {} : { note }
+    };
+  }));
+  server.registerTool("impact", {
+    title: "Blast radius",
+    description: "Every entry point that can reach a symbol, which services they belong to, and which services the chain runs into without an entry point above them. What would have to be retested if this changed.",
+    inputSchema: {
+      symbol: z6.string().describe("a node id, or a name close enough to identify one"),
+      ...commonInput
+    }
+  }, (input) => withDb(ctx.handle, (db) => {
+    const { detail, maxNodes, note } = bound(input);
+    const found = findTarget(db, input.symbol);
+    if (Array.isArray(found)) {
+      return found.length === 0 ? { error: `no symbol matches ${JSON.stringify(input.symbol)}` } : { candidates: found.map((node) => projectDetail(node, detail)) };
+    }
+    const reach = db.reverseReach(found.id, { edgeTypes: REVERSE_EDGES, maxDepth: 12, maxNodes: 4e3 });
+    const entries = [];
+    const channels = /* @__PURE__ */ new Set();
+    const entriesByService = {};
+    const reachedByService = {};
+    let reached = 0;
+    for (const row of reach.rows) {
+      if (row.id === found.id)
+        continue;
+      reached += 1;
+      const node = db.node(row.id);
+      if (node !== void 0) {
+        reachedByService[node.repo] = (reachedByService[node.repo] ?? 0) + 1;
+      }
+      if (row.type === "channel")
+        channels.add(row.id);
+      if (row.type !== "entry" || node === void 0)
+        continue;
+      entries.push(node);
+      entriesByService[node.repo] = (entriesByService[node.repo] ?? 0) + 1;
+    }
+    const servicesWithoutEntry = Object.keys(reachedByService).filter((repo) => entriesByService[repo] === void 0).sort();
+    entries.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    const { items, truncated } = truncate(entries, maxNodes);
+    return {
+      target: projectDetail(found, detail),
+      entries: items.map((entry) => projectDetail(entry, detail)),
+      // How many things reach it at all, so no entry points is telling
+      // rather than indistinguishable from nothing reaching it.
+      reached,
+      entriesByService,
+      reachedByService,
+      servicesWithoutEntry,
+      channels: [...channels].sort(),
+      ...truncated === void 0 ? {} : { truncated },
+      ...reach.truncated ? { note: "reachability stopped at the walk limit" } : {},
+      ...note === void 0 ? {} : { note }
+    };
+  }));
+};
+
+// ../mcp/dist/tools/source.js
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { z as z7 } from "zod";
+var endOfDeclaration = (lines, startIndex) => {
+  let depth = 0;
+  let seen = false;
+  for (let index = startIndex; index < lines.length; index += 1) {
+    for (const character of lines[index] ?? "") {
+      if (character === "{") {
+        depth += 1;
+        seen = true;
+      } else if (character === "}")
+        depth -= 1;
+    }
+    if (seen && depth <= 0)
+      return index;
+    if (!seen && index > startIndex + 40)
+      return index;
+  }
+  return lines.length - 1;
+};
+var registerSource = (server, ctx) => {
+  server.registerTool("get_source", {
+    title: "Read the source of a symbol",
+    description: "The actual code of one symbol. The only tool that returns source; ask for it by name once the graph has told you which name to ask for.",
+    inputSchema: {
+      symbol: z7.string().describe("a node id"),
+      context: z7.number().int().min(0).max(50).default(0).describe("extra lines either side")
+    }
+  }, (input) => withDb(ctx.handle, (db) => {
+    const node = db.node(input.symbol.trim());
+    if (node === void 0)
+      return { error: `no symbol with id ${JSON.stringify(input.symbol)}` };
+    if (node.file === void 0)
+      return { error: "source unavailable", reason: "the node records no file" };
+    const root = ctx.handle.repoDir(node.repo);
+    if (root === void 0) {
+      return { error: "source unavailable", reason: `no repository configured for ${node.repo}`, file: node.file };
+    }
+    const path = join(root, node.file);
+    if (!existsSync2(path))
+      return { error: "source unavailable", file: path };
+    const lines = readFileSync(path, "utf8").split("\n");
+    const start = Math.max((node.line ?? 1) - 1, 0);
+    const end = endOfDeclaration(lines, start);
+    const from = Math.max(start - input.context, 0);
+    const to = Math.min(end + input.context, lines.length - 1);
+    return {
+      id: node.id,
+      file: node.file,
+      line: from + 1,
+      endLine: to + 1,
+      code: lines.slice(from, to + 1).join("\n")
+    };
+  }));
+};
+
+// ../mcp/dist/tools/types.js
+import { z as z8 } from "zod";
+var referencedIds = (entry) => {
+  const found = /* @__PURE__ */ new Set();
+  for (const field of entry.fields ?? []) {
+    for (const match of field.type.matchAll(/type:[^\s,;()[\]{}<>|&]+/g))
+      found.add(match[0]);
+  }
+  for (const member of entry.members ?? []) {
+    for (const match of member.matchAll(/type:[^\s,;()[\]{}<>|&]+/g))
+      found.add(match[0]);
+  }
+  return [...found];
+};
+var expandType = (db, id, depth) => {
+  const nested = {};
+  let frontier = [id];
+  for (let level = 0; level < depth && frontier.length > 0; level += 1) {
+    const next = [];
+    for (const current of frontier) {
+      const entry = db.type(current);
+      if (entry === void 0)
+        continue;
+      for (const referenced of referencedIds(entry)) {
+        if (referenced === id || nested[referenced] !== void 0)
+          continue;
+        const found = db.type(referenced);
+        if (found === void 0)
+          continue;
+        nested[referenced] = found;
+        next.push(referenced);
+      }
+    }
+    frontier = next;
+  }
+  return nested;
+};
+var registerTypes = (server, ctx) => {
+  server.registerTool("get_type", {
+    title: "Read a type",
+    description: "The structure of a type from the registry, with the types it refers to expanded to a depth. Accepts a full type id or a bare name.",
+    inputSchema: {
+      type: z8.string().describe("a type id such as type:orders#OrderDto, or a bare name"),
+      depth: z8.number().int().min(0).max(6).default(3).describe("how deep to expand nesting"),
+      ...commonInput
+    }
+  }, (input) => withDb(ctx.handle, (db) => {
+    const { note } = bound(input);
+    const asked = input.type.trim();
+    let id = asked;
+    if (!asked.startsWith("type:")) {
+      const named = db.typesByName(asked);
+      if (named.length === 0)
+        return { error: `no type named ${JSON.stringify(asked)}` };
+      if (named.length > 1)
+        return { candidates: named.map((entry2) => entry2.id) };
+      id = named[0].id;
+    }
+    const entry = db.type(id);
+    if (entry === void 0)
+      return { error: `no type with id ${JSON.stringify(id)}` };
+    return {
+      type: entry,
+      nested: expandType(db, id, input.depth),
+      ...note === void 0 ? {} : { note }
+    };
+  }));
+};
+
+// ../mcp/dist/server.js
+var SERVER_NAME = "flowatlas";
+var createFlowatlasServer = (options = {}) => {
+  const handle = new DbHandle(options);
+  const context = {
+    handle,
+    ...options.contractChecker === void 0 ? {} : { contractChecker: options.contractChecker }
+  };
+  const server = new McpServer({ name: SERVER_NAME, version: options.version ?? "0.0.0" }, {
+    instructions: "A map of every repository in this project, already joined. Ask it what reaches what instead of reading files: list_entries to find a way in, get_flow to follow one through every service it touches, who_calls and impact to work backwards, who_emits and who_consumes for message channels, get_type for a shape, check_contract for whether two services still agree, find_symbol when you only half remember a name. Every answer is bounded; get_source is the only one that returns code."
+  });
+  registerEntries(server, context);
+  registerFlow(server, context);
+  registerReach(server, context);
+  registerChannels(server, context);
+  registerTypes(server, context);
+  registerContract(server, context);
+  registerSource(server, context);
+  return server;
+};
+var startStdioServer = async (options = {}) => {
+  const server = createFlowatlasServer(options);
+  await server.connect(new StdioServerTransport());
+  return server;
+};
+
+export {
+  DbHandle,
+  truncationMessage,
+  MAX_DETAIL,
+  CLAMP_NOTE,
+  clampDetail,
+  projectDetail,
+  projectEdge,
+  truncate,
+  isResolved,
+  resolveEntryRef,
+  FORWARD_EDGES,
+  REVERSE_EDGES,
+  buildFlowTree,
+  flatten,
+  endOfDeclaration,
+  expandType,
+  SERVER_NAME,
+  createFlowatlasServer,
+  startStdioServer
+};