@eventcatalog/core 5.5.0 → 5.5.1

package/eventcatalog/src/features/mcp/mcp-apps.ts

@@ -93,7 +93,7 @@ export function registerMcpApp<Shape extends z.ZodRawShape, ViewShape extends z.
       if ('error' in result) return errorResult(result);
       return {
         // The model reads the text; hosts that support MCP Apps show the view from `_meta`
-        content: [{ type: 'text' as const, text: JSON.stringify(result.forModel, null, 2) }],
+        content: [{ type: 'text' as const, text: JSON.stringify(result.forModel) }],
         ...(loadView && {
           _meta: {
             [app.metaKey]: await result.getPayload(),

package/eventcatalog/src/features/mcp/mcp-server.ts

@@ -48,7 +48,8 @@ type McpServerOptions = {
 
 const catalogDirectory = process.env.PROJECT_DIR || process.cwd();
 
-// Helper to create consistent MCP tool handlers with error handling
+// Helper to create consistent MCP tool handlers with error handling. Results are compact JSON: indenting them costs
+// the model about a fifth more tokens for nothing
 function createToolHandler<T>(fn: (params: T) => Promise<any>, errorMessage: string) {
   return async (params: T) => {
     try {
@@ -62,7 +63,7 @@ function createToolHandler<T>(fn: (params: T) => Promise<any>, errorMessage: str
       }
 
       return {
-        content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }],
+        content: [{ type: 'text' as const, text: JSON.stringify(result) }],
       };
     } catch (error) {
       return {
@@ -665,7 +666,7 @@ function createMcpServer(
         try {
           const result = await execute(params);
           return {
-            content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }],
+            content: [{ type: 'text' as const, text: JSON.stringify(result) }],
           };
         } catch (error) {
           return {
@@ -840,7 +841,7 @@ function createMcpServer(
           contents: [
             {
               uri: uri.href,
-              text: JSON.stringify({ ...(scope && { scope: scope.ref }), resources: allResources }, null, 2),
+              text: JSON.stringify({ ...(scope && { scope: scope.ref }), resources: allResources }),
               mimeType: 'application/json',
             },
           ],

package/eventcatalog/src/features/mcp/schema-viewer.ts

@@ -3,7 +3,7 @@ import { getLanguageForHighlight } from '@components/SchemaExplorer/utils';
 import { getSchemaExtensionForFormat } from '@utils/collections/schemas';
 import type { SchemaViewerSchema } from './apps/schema-viewer/shared';
 
-type SchemaToolResult = { name?: string; format?: string; url?: string; code: string };
+type SchemaToolResult = { name?: string; format?: string; path?: string; code: string };
 
 /**
  * The schemas returned by getSchemaForResource, ready for the schema viewer: parsed for its Properties tab
@@ -12,11 +12,11 @@ type SchemaToolResult = { name?: string; format?: string; url?: string; code: st
 export const toSchemaViewerSchemas = (schemas: SchemaToolResult[]): SchemaViewerSchema[] =>
   schemas.map((schema) => {
     // Schemas in the schemas collection have a format (jsonschema, avro, protobuf), others a file extension
-    const format = schema.format ?? schema.url?.split('.').pop() ?? '';
+    const format = schema.format ?? schema.path?.split('.').pop() ?? '';
     const extension = getSchemaExtensionForFormat(format);
     return {
       ...parseSchemaForViewer(extension, schema.code),
-      ...(schemas.length > 1 && { name: schema.name ?? schema.url?.split('/').pop() ?? format }),
+      ...(schemas.length > 1 && { name: schema.name ?? schema.path?.split('/').pop() ?? format }),
       format,
       language: getLanguageForHighlight(extension),
       code: schema.code,

package/eventcatalog/src/features/studio/server/canvas-mcp.ts

@@ -52,7 +52,7 @@ const CANVAS_ICON_SVG =
 const CANVAS_ICON = { src: `data:image/svg+xml;base64,${btoa(CANVAS_ICON_SVG)}`, mimeType: 'image/svg+xml', sizes: ['20x20'] };
 
 const text = (value: unknown, isError = false) => ({
-  content: [{ type: 'text' as const, text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) }],
+  content: [{ type: 'text' as const, text: typeof value === 'string' ? value : JSON.stringify(value) }],
   ...(isError && { isError }),
 });
 

package/eventcatalog/src/features/tools/catalog-tools.ts

@@ -4,8 +4,8 @@
  */
 import { getCollection } from 'astro:content';
 import { z } from 'zod';
-import { getSchemasFromResource, getSchemaFormatFromURL } from '@utils/collections/schemas';
-import { getItemsFromCollectionByIdAndSemverOrLatest } from '@utils/collections/util';
+import { getSchemaFormatFromURL } from '@utils/collections/schemas';
+import { getItemsFromCollectionByIdAndSemverOrLatest, processSpecifications, versionMatches } from '@utils/collections/util';
 import { getUbiquitousLanguageWithSubdomains } from '@utils/collections/domains';
 import { getAbsoluteFilePathForAstroFile } from '@utils/files';
 import fs from 'node:fs';
@@ -280,6 +280,74 @@ export async function getResource(params: { collection: string; id: string; vers
 
 type MessagePointer = { id: string; version?: string };
 
+type MessageEntry = { collection: string; data: { id: string; version: string } };
+
+/** Resources that send and receive messages, and the collections that hold them */
+const MESSAGING_COLLECTIONS = ['services', 'agents', 'domains'] as const;
+
+/** Old versions live in a versioned folder: what they send and receive is history, not the catalog today */
+const isLatestVersion = (entry: { filePath?: string }) => !entry.filePath?.includes('versioned');
+
+/**
+ * Whether a sends/receives pointer points at this version of a message, as on the message's pages: one without a
+ * version (or "latest") points at the latest version only; others match exactly, by semver range or by x-pattern (1.x)
+ */
+const pointsAtMessage = (pointer: MessagePointer, message: MessageEntry, latestVersion: string) => {
+  if (pointer.id !== message.data.id) return false;
+  if (!pointer.version || pointer.version === 'latest') return message.data.version === latestVersion;
+  return versionMatches(message.data.version, pointer.version);
+};
+
+/** The services, agents and domains (latest versions) that send (or receive) this version of a message */
+const getResourcesThat = async (direction: 'sends' | 'receives', message: MessageEntry) => {
+  const [latestMessage, ...collections] = await Promise.all([
+    findEntry(message.collection, message.data.id),
+    ...MESSAGING_COLLECTIONS.map((collection) => getCollection(collection)),
+  ]);
+  const latestVersion = latestMessage?.data.version ?? message.data.version;
+
+  return collections
+    .flat()
+    .filter(isLatestVersion)
+    .filter((resource) =>
+      ((resource.data as any)[direction] || []).some((pointer: MessagePointer) =>
+        pointsAtMessage(pointer, message, latestVersion)
+      )
+    );
+};
+
+/**
+ * The resources a domain or system is made of, with it: its services and agents, and for a domain its systems and
+ * subdomains (and everything inside them)
+ */
+const getResourcesInside = async (container: any) => {
+  const [domains, systems, services, agents] = await Promise.all(
+    (['domains', 'systems', 'services', 'agents'] as const).map((collection) => getCollection(collection))
+  );
+  const resolve = (entries: any[], pointers: MessagePointer[] = []) =>
+    pointers
+      .map((pointer) => getItemsFromCollectionByIdAndSemverOrLatest(entries, pointer.id, pointer.version)[0])
+      .filter(Boolean);
+
+  const found = new Map<string, any>();
+  const visit = (entry: any) => {
+    const key = `${entry.collection}/${entry.data.id}`;
+    if (found.has(key)) return;
+    found.set(key, entry);
+    if (entry.collection !== 'domains' && entry.collection !== 'systems') return;
+    [
+      ...resolve(services, entry.data.services),
+      ...resolve(agents, entry.data.agents),
+      ...(entry.collection === 'domains'
+        ? [...resolve(systems, entry.data.systems), ...resolve(domains, entry.data.domains)]
+        : []),
+    ].forEach(visit);
+  };
+  visit(container);
+
+  return [...found.values()];
+};
+
 /**
  * Resolve a sends/receives pointer to the documented message it points at
  */
@@ -321,17 +389,39 @@ export async function getMessagesProducedOrConsumedByResource(params: {
     getCollection('queries'),
   ]);
   const messages = [...events, ...commands, ...queries];
+  const summary = {
+    id: resource.data.id,
+    version: resource.data.version,
+    name: resource.data.name || resource.data.id,
+    collection: params.resourceCollection,
+  };
 
-  return {
-    resource: {
-      id: resource.data.id,
-      version: resource.data.version,
-      name: resource.data.name || resource.data.id,
-      collection: params.resourceCollection,
-    },
-    sends: (resource.data.sends || []).map((pointer: MessagePointer) => resolveMessagePointer(messages, pointer)),
-    receives: (resource.data.receives || []).map((pointer: MessagePointer) => resolveMessagePointer(messages, pointer)),
+  if (params.resourceCollection !== 'domains' && params.resourceCollection !== 'systems') {
+    return {
+      resource: summary,
+      sends: (resource.data.sends || []).map((pointer: MessagePointer) => resolveMessagePointer(messages, pointer)),
+      receives: (resource.data.receives || []).map((pointer: MessagePointer) => resolveMessagePointer(messages, pointer)),
+    };
+  }
+
+  // A domain or system sends and receives what it and everything inside it does: `by` names who, e.g. services/orders
+  const members = await getResourcesInside(resource);
+  const collect = (direction: 'sends' | 'receives') => {
+    const found = new Map<string, ReturnType<typeof resolveMessagePointer> & { by: string[] }>();
+    for (const member of members) {
+      for (const pointer of (member.data[direction] || []) as MessagePointer[]) {
+        const message = resolveMessagePointer(messages, pointer);
+        const key = `${message.collection ?? ''}/${message.id}@${message.version}`;
+        const entry = found.get(key) ?? { ...message, by: [] };
+        const by = `${member.collection}/${member.data.id}`;
+        if (!entry.by.includes(by)) entry.by.push(by);
+        found.set(key, entry);
+      }
+    }
+    return [...found.values()];
   };
+
+  return { resource: summary, sends: collect('sends'), receives: collect('receives') };
 }
 
 /**
@@ -367,15 +457,27 @@ export async function getSchemaForResource(params: { resourceId: string; resourc
     }
   }
 
-  const schema = await getSchemasFromResource(resource);
+  const files = [
+    ...(resource.data.schemaPath
+      ? [{ path: resource.data.schemaPath, format: getSchemaFormatFromURL(resource.data.schemaPath) }]
+      : []),
+    ...processSpecifications(resource.data.specifications).map((spec) => ({
+      name: spec.name,
+      path: spec.path,
+      format: spec.type,
+    })),
+  ];
+
+  // Read from beside the resource's own file (paths are relative to it); files that can't be read are left out
+  const schemas = files.flatMap((file) => {
+    try {
+      return [{ ...file, code: fs.readFileSync(getAbsoluteFilePathForAstroFile(resource.filePath ?? '', file.path), 'utf-8') }];
+    } catch {
+      return [];
+    }
+  });
 
-  if (schema.length > 0) {
-    return schema.map((schemaItem) => ({
-      url: schemaItem.url,
-      format: schemaItem.format,
-      code: fs.readFileSync(schemaItem.url, 'utf-8'),
-    }));
-  }
+  if (schemas.length > 0) return schemas;
 
   return { message: 'No schemas found for this resource' };
 }
@@ -431,8 +533,6 @@ export async function findResourcesByOwner(params: { ownerId: string }) {
  * Get resources that produce (send) a specific message
  */
 export async function getProducersOfMessage(params: { messageId: string; messageVersion?: string; messageCollection: string }) {
-  const [services, agents] = await Promise.all([getCollection('services'), getCollection('agents')]);
-  const routableResources = [...services, ...agents];
   const message = await findEntry(params.messageCollection, params.messageId, params.messageVersion);
 
   if (!message) {
@@ -440,21 +540,13 @@ export async function getProducersOfMessage(params: { messageId: string; message
       error: `Message not found: ${params.messageId} (${describeVersion(params.messageVersion)}) in ${params.messageCollection}`,
     };
   }
-  const messageVersion = message.data.version;
 
-  const producers = routableResources.filter((resource) => {
-    const sends = (resource.data as any).sends || [];
-    return sends.some((send: any) => {
-      const idMatch = send.id === params.messageId;
-      if (!send.version || send.version === 'latest') return idMatch;
-      return idMatch && send.version === messageVersion;
-    });
-  });
+  const producers = await getResourcesThat('sends', message);
 
   return {
     message: {
       id: params.messageId,
-      version: messageVersion,
+      version: message.data.version,
       collection: params.messageCollection,
     },
     producers: producers.map((s) => ({
@@ -511,8 +603,6 @@ export async function getC4Diagram(params: { viewId?: string }) {
  * Get resources that consume (receive) a specific message
  */
 export async function getConsumersOfMessage(params: { messageId: string; messageVersion?: string; messageCollection: string }) {
-  const [services, agents] = await Promise.all([getCollection('services'), getCollection('agents')]);
-  const routableResources = [...services, ...agents];
   const message = await findEntry(params.messageCollection, params.messageId, params.messageVersion);
 
   if (!message) {
@@ -520,21 +610,13 @@ export async function getConsumersOfMessage(params: { messageId: string; message
       error: `Message not found: ${params.messageId} (${describeVersion(params.messageVersion)}) in ${params.messageCollection}`,
     };
   }
-  const messageVersion = message.data.version;
 
-  const consumers = routableResources.filter((resource) => {
-    const receives = (resource.data as any).receives || [];
-    return receives.some((receive: any) => {
-      const idMatch = receive.id === params.messageId;
-      if (!receive.version || receive.version === 'latest') return idMatch;
-      return idMatch && receive.version === messageVersion;
-    });
-  });
+  const consumers = await getResourcesThat('receives', message);
 
   return {
     message: {
       id: params.messageId,
-      version: messageVersion,
+      version: message.data.version,
       collection: params.messageCollection,
     },
     consumers: consumers.map((s) => ({
@@ -552,8 +634,6 @@ export async function getConsumersOfMessage(params: { messageId: string; message
  * Returns all affected services (producers and consumers) and their owners
  */
 export async function analyzeChangeImpact(params: { messageId: string; messageVersion?: string; messageCollection: string }) {
-  const [services, agents] = await Promise.all([getCollection('services'), getCollection('agents')]);
-  const routableResources = [...services, ...agents];
   const message = await findEntry(params.messageCollection, params.messageId, params.messageVersion);
 
   if (!message) {
@@ -563,17 +643,7 @@ export async function analyzeChangeImpact(params: { messageId: string; messageVe
   }
   const messageVersion = message.data.version;
 
-  // Find producers
-  const producers = routableResources.filter((resource) => {
-    const sends = (resource.data as any).sends || [];
-    return sends.some((send: any) => send.id === params.messageId);
-  });
-
-  // Find consumers
-  const consumers = routableResources.filter((resource) => {
-    const receives = (resource.data as any).receives || [];
-    return receives.some((receive: any) => receive.id === params.messageId);
-  });
+  const [producers, consumers] = await Promise.all([getResourcesThat('sends', message), getResourcesThat('receives', message)]);
 
   // Collect all affected teams/owners
   const affectedOwners = new Set<string>();
@@ -796,19 +866,10 @@ export async function findMessageBySchemaId(params: {
     const matches = getItemsFromCollectionByIdAndSemverOrLatest(collection, params.messageId, params.messageVersion);
     const resource = matches[0];
     if (resource) {
-      // Get producers and consumers
-      const [services, agents] = await Promise.all([getCollection('services'), getCollection('agents')]);
-      const routableResources = [...services, ...agents];
-
-      const producers = routableResources.filter((resource) => {
-        const sends = (resource.data as any).sends || [];
-        return sends.some((send: any) => send.id === params.messageId);
-      });
-
-      const consumers = routableResources.filter((resource) => {
-        const receives = (resource.data as any).receives || [];
-        return receives.some((receive: any) => receive.id === params.messageId);
-      });
+      const [producers, consumers] = await Promise.all([
+        getResourcesThat('sends', resource),
+        getResourcesThat('receives', resource),
+      ]);
 
       return {
         resource: {
@@ -1265,23 +1326,23 @@ export async function getCustomDoc(params: { id: string; section?: string }) {
 
 export const toolDescriptions = {
   getResources:
-    'Use this tool to get events, agents, services, commands, queries, flows, domains, channels, entities from EventCatalog. Supports pagination via cursor and filtering by search term (searches name, id, and summary).',
+    'Use this tool to list the resources in a collection of EventCatalog (events, commands, queries, services, agents, domains, systems, flows, channels, entities, containers, data products, diagrams or ADRs). Supports pagination via cursor and filtering by search term (searches name, id, and summary).',
   getResource:
     'Use this tool to get a specific resource from EventCatalog by its id. Returns the frontmatter and markdown documentation. Omit the version to get the latest version.',
   getMessagesProducedOrConsumedByResource:
-    'Use this tool to get the messages (events, commands, queries) a service, agent or domain sends and receives. Each message is resolved to its catalog id, version, name and summary; messages that are referenced but not documented in the catalog are marked notFound. Omit the version to use the latest version of the resource.',
+    'Use this tool to get the messages (events, commands, queries) a service, agent, domain or system sends and receives. Each message is resolved to its catalog id, version, name and summary; messages that are referenced but not documented in the catalog are marked notFound. For a domain or system, this includes what the services, agents, systems and subdomains inside it send and receive, and each message lists `by`: the resources that send or receive it (e.g. services/order-service). Omit the version to use the latest version of the resource.',
   getSchemaForResource:
     'Use this tool to get the schema or specifications (openapi or asyncapi or graphql) for a resource by its id and version',
   findResourcesByOwner:
     'Use this tool to find all resources (agents, services, events, commands, etc.) owned by a specific team or user',
   getProducersOfMessage:
-    'Use this tool to find which agents or services produce (send) a specific message (event, command, or query)',
+    'Use this tool to find which services, agents or domains produce (send) a specific message (event, command, or query). Only the latest versions of those resources are included.',
   getConsumersOfMessage:
-    'Use this tool to find which agents or services consume (receive) a specific message (event, command, or query)',
+    'Use this tool to find which services, agents or domains consume (receive) a specific message (event, command, or query). Only the latest versions of those resources are included.',
   getC4Diagram:
     'Use this tool to get the C4 diagram (or likeC4) in EventCatalog. These files usually have a .c4 extension on them',
   analyzeChangeImpact:
-    'Use this tool to analyze the impact of changing a message. Returns all affected agents and services (producers and consumers), the teams that own them, and the blast radius of the change',
+    'Use this tool to analyze the impact of changing a message. Returns all affected services, agents and domains (producers and consumers), the teams that own them, and the blast radius of the change',
   explainBusinessFlow:
     'Use this tool to get detailed information about a business flow (state machine). Returns the flow definition, steps, mermaid diagram if available, and related agents and services',
   getTeams:

package/package.json

@@ -7,7 +7,7 @@
   },
   "license": "BUSL-1.1",
   "type": "module",
-  "version": "5.5.0",
+  "version": "5.5.1",
   "publishConfig": {
     "access": "public"
   },
@@ -69,7 +69,7 @@
     "@modelcontextprotocol/ext-apps": "2.0.3",
     "@modelcontextprotocol/server": "2.3.1",
     "@nanostores/react": "^1.0.0",
-    "@parcel/watcher": "^2.4.1",
+    "@parcel/watcher": "^2.5.4",
     "@radix-ui/react-context-menu": "^2.2.6",
     "@radix-ui/react-dialog": "^1.1.6",
     "@radix-ui/react-dropdown-menu": "^2.1.12",
@@ -141,11 +141,11 @@
     "y-protocols": "^1.0.7",
     "yjs": "^13.6.33",
     "zod": "^4.6.6",
-    "@eventcatalog/exporters": "0.1.2",
     "@eventcatalog/fitness": "0.1.0",
     "@eventcatalog/linter": "1.2.4",
-    "@eventcatalog/visualiser": "^5.1.0",
-    "@eventcatalog/sdk": "2.31.2"
+    "@eventcatalog/sdk": "2.31.2",
+    "@eventcatalog/exporters": "0.1.2",
+    "@eventcatalog/visualiser": "^5.1.0"
   },
   "devDependencies": {
     "@astrojs/check": "^0.9.10",
@@ -171,7 +171,7 @@
     "prettier": "^3.3.3",
     "prettier-plugin-astro": "^0.14.1",
     "tsup": "^8.1.0",
-    "vite": "^8.1.0",
+    "vite": "^8.1.6",
     "vite-tsconfig-paths": "^4.3.2",
     "vitest": "^4.0.18"
   },

package/dist/{chunk-QJ7KKN2D.js → chunk-NCEZDQSW.js}

@@ -1,3 +1,10 @@
+import {
+  createFederationContentCache
+} from "./chunk-R7Z5ALYI.js";
+import {
+  getFederationDiagnostics,
+  resolveFederationRules
+} from "./chunk-JJPB6EOZ.js";
 import {
   withFederationOutputTransaction
 } from "./chunk-WRNH5C3U.js";
@@ -7,13 +14,6 @@ import {
 import {
   createFederationSourceProvider
 } from "./chunk-A2RZR3U4.js";
-import {
-  createFederationContentCache
-} from "./chunk-R7Z5ALYI.js";
-import {
-  getFederationDiagnostics,
-  resolveFederationRules
-} from "./chunk-JJPB6EOZ.js";
 import {
   getEventCatalogConfigFile
 } from "./chunk-4G7FSRPN.js";