@eventcatalog/cli 0.3.1 → 0.3.3

package/dist/cli/index.mjs

@@ -9,8 +9,8 @@ var __dirname = /* @__PURE__ */ getDirname();
 
 // src/cli/index.ts
 import { program } from "commander";
-import { readFileSync } from "fs";
-import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
 
 // src/cli/executor.ts
 import { existsSync } from "fs";
@@ -124,6 +124,7 @@ import { resolve } from "path";
 import open from "open";
 import createSDK3 from "@eventcatalog/sdk";
 var RESOURCE_TYPES = ["event", "command", "query", "service", "domain"];
+var SUPPORTED_RESOURCE_TYPES = RESOURCE_TYPES.join(", ");
 var PLURAL_MAP = {
   events: "event",
   commands: "command",
@@ -131,11 +132,40 @@ var PLURAL_MAP = {
   services: "service",
   domains: "domain"
 };
+var KNOWN_UNSUPPORTED_EXPORT_TYPES = /* @__PURE__ */ new Set([
+  "channel",
+  "channels",
+  "team",
+  "teams",
+  "user",
+  "users",
+  "container",
+  "containers",
+  "data-product",
+  "data-products",
+  "dataproduct",
+  "dataproducts",
+  "diagram",
+  "diagrams",
+  "flow",
+  "flows"
+]);
 function normalizeResourceType(resource) {
   const lower = resource.toLowerCase();
   if (PLURAL_MAP[lower]) return PLURAL_MAP[lower];
   return lower;
 }
+function assertSupportedExportType(resource, type) {
+  const lower = resource.toLowerCase();
+  if (KNOWN_UNSUPPORTED_EXPORT_TYPES.has(lower)) {
+    throw new Error(
+      `Resource type '${resource}' is not yet supported for DSL export. Supported types: ${SUPPORTED_RESOURCE_TYPES}`
+    );
+  }
+  if (!RESOURCE_TYPES.includes(type)) {
+    throw new Error(`Invalid resource type '${resource}'. Must be one of: ${SUPPORTED_RESOURCE_TYPES}`);
+  }
+}
 function getResourceFetcher(sdk, type) {
   switch (type) {
     case "event":
@@ -226,14 +256,14 @@ ${entries.join("\n")}
 async function exportCatalog(options) {
   const { hydrate = false, stdout = false, playground = false, output, dir } = options;
   const sdk = createSDK3(dir);
-  const dslParts = [];
-  for (const type of RESOURCE_TYPES) {
-    const fetcher = getCollectionFetcher(sdk, type);
-    const resources = await fetcher({ latestOnly: true });
-    if (!resources || resources.length === 0) continue;
-    const rawDsl = await sdk.toDSL(resources, { type, hydrate });
-    dslParts.push(rawDsl);
-  }
+  const dslParts = (await Promise.all(
+    RESOURCE_TYPES.map(async (type) => {
+      const fetcher = getCollectionFetcher(sdk, type);
+      const resources = await fetcher({ latestOnly: true });
+      if (!resources || resources.length === 0) return "";
+      return sdk.toDSL(resources, { type, hydrate });
+    })
+  )).filter((dsl2) => Boolean(dsl2));
   if (dslParts.length === 0) {
     throw new Error(`No resources found in catalog at '${dir}'`);
   }
@@ -253,9 +283,9 @@ ${vizBlock}` : grouped;
     const encoded = Buffer.from(dsl).toString("base64");
     const playgroundUrl = `https://playground.eventcatalog.dev/?code=${encoded}`;
     await open(playgroundUrl);
-    lines.push("", `  Opening in playground...`);
+    lines.push("", `  Opening in EventCatalog Modelling...`);
   } else {
-    lines.push("", `  Tip: Use --playground to open in the playground`);
+    lines.push("", `  Tip: Use --playground to open in EventCatalog Modelling`);
   }
   lines.push("");
   return lines.join("\n");
@@ -263,9 +293,7 @@ ${vizBlock}` : grouped;
 async function exportAll(options) {
   const { resource, hydrate = false, stdout = false, playground = false, output, dir } = options;
   const type = normalizeResourceType(resource);
-  if (!RESOURCE_TYPES.includes(type)) {
-    throw new Error(`Invalid resource type '${resource}'. Must be one of: ${RESOURCE_TYPES.join(", ")}`);
-  }
+  assertSupportedExportType(resource, type);
   const plural = pluralize(type);
   const sdk = createSDK3(dir);
   const fetcher = getCollectionFetcher(sdk, type);
@@ -289,9 +317,9 @@ ${vizBlock}` : grouped;
     const encoded = Buffer.from(dsl).toString("base64");
     const playgroundUrl = `https://playground.eventcatalog.dev/?code=${encoded}`;
     await open(playgroundUrl);
-    lines.push("", `  Opening in playground...`);
+    lines.push("", `  Opening in EventCatalog Modelling...`);
   } else {
-    lines.push("", `  Tip: Use --playground to open in the playground`);
+    lines.push("", `  Tip: Use --playground to open in EventCatalog Modelling`);
   }
   lines.push("");
   return lines.join("\n");
@@ -302,9 +330,7 @@ async function exportResource(options) {
     return exportAll(options);
   }
   const type = normalizeResourceType(resource);
-  if (!RESOURCE_TYPES.includes(type)) {
-    throw new Error(`Invalid resource type '${resource}'. Must be one of: ${RESOURCE_TYPES.join(", ")}`);
-  }
+  assertSupportedExportType(resource, type);
   const sdk = createSDK3(dir);
   const fetcher = getResourceFetcher(sdk, type);
   const data = await fetcher(id, version2);
@@ -328,19 +354,739 @@ ${vizBlock}` : grouped;
     const encoded = Buffer.from(dsl).toString("base64");
     const playgroundUrl = `https://playground.eventcatalog.dev/?code=${encoded}`;
     await open(playgroundUrl);
-    lines.push("", `  Opening in playground...`);
+    lines.push("", `  Opening in EventCatalog Modelling...`);
   } else {
-    lines.push("", `  Tip: Use --playground to open in the playground`);
+    lines.push("", `  Tip: Use --playground to open in EventCatalog Modelling`);
   }
   lines.push("");
   return lines.join("\n");
 }
 
+// src/cli/import.ts
+import { readFileSync, existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2, copyFileSync } from "fs";
+import { resolve as resolve2, join } from "path";
+import { randomUUID } from "crypto";
+import { createInterface } from "readline";
+import matter from "gray-matter";
+import createSDK4 from "@eventcatalog/sdk";
+function normalizeImportedFrontmatter(type, frontmatter) {
+  const normalized = { ...frontmatter };
+  if (type === "container") {
+    if (normalized.container_type === void 0 && normalized.containerType !== void 0) {
+      normalized.container_type = normalized.containerType;
+      delete normalized.containerType;
+    }
+    if (normalized.access_mode === void 0 && normalized.accessMode !== void 0) {
+      normalized.access_mode = normalized.accessMode;
+      delete normalized.accessMode;
+    }
+  }
+  return normalized;
+}
+var RESOURCE_TYPE_FROM_FOLDER = {
+  events: "event",
+  commands: "command",
+  queries: "query",
+  services: "service",
+  domains: "domain",
+  channels: "channel",
+  flows: "flow",
+  containers: "container",
+  "data-products": "dataProduct",
+  diagrams: "diagram",
+  users: "user",
+  teams: "team"
+};
+async function parseDSL(source, options) {
+  const { createEcServices, compile } = await import("@eventcatalog/language-server");
+  const { EmptyFileSystem, URI } = await import("langium");
+  const services = createEcServices(EmptyFileSystem);
+  const uri = URI.parse(`file:///import-${Date.now()}.ec`);
+  const document = services.shared.workspace.LangiumDocumentFactory.fromString(source, uri);
+  services.shared.workspace.LangiumDocuments.addDocument(document);
+  await services.shared.workspace.DocumentBuilder.build([document]);
+  const parserErrors = document.parseResult.parserErrors;
+  if (parserErrors.length > 0) {
+    const messages = parserErrors.map((e) => `  Line ${e.token?.startLine ?? "?"}: ${e.message}`);
+    throw new Error(`Parse errors:
+${messages.join("\n")}`);
+  }
+  const program2 = document.parseResult.value;
+  const outputs = compile(program2, { nested: options?.nested });
+  try {
+    services.shared.workspace.LangiumDocuments.deleteDocument(uri);
+  } catch {
+  }
+  return { outputs, program: program2 };
+}
+function extractResourceTypeFolder(path2) {
+  const segments = path2.split("/");
+  let lastTypeFolder = segments[0];
+  for (const seg of segments) {
+    if (RESOURCE_TYPE_FROM_FOLDER[seg]) {
+      lastTypeFolder = seg;
+    }
+  }
+  return lastTypeFolder;
+}
+function parseCompiledOutput(output) {
+  const { data: frontmatter, content: markdown } = matter(output.content);
+  const typeFolder = extractResourceTypeFolder(output.path);
+  const type = RESOURCE_TYPE_FROM_FOLDER[typeFolder] || typeFolder;
+  return {
+    type,
+    id: frontmatter.id,
+    version: frontmatter.version,
+    frontmatter,
+    markdown: markdown.trim(),
+    path: output.path
+  };
+}
+var MESSAGE_TYPE_FOLDER = {
+  event: "events",
+  command: "commands",
+  query: "queries",
+  channel: "channels"
+};
+var DEFAULT_STUB_VERSION = "0.0.1";
+var NO_VERSION_KEY = "__no_version__";
+function getResourceNameKey(type, id) {
+  return `${type}:${id}`;
+}
+function getResourceVersionKey(type, id, version2) {
+  return `${type}:${id}@${version2 || NO_VERSION_KEY}`;
+}
+function hasReferenceStatements(source) {
+  return /\b(?:sends|receives|writes-to|reads-from)\b/.test(source);
+}
+async function extractMessageStubs(program2, compiledIds, nested = false) {
+  const stubs = [];
+  const stubIds = /* @__PURE__ */ new Set();
+  function processDefinitions(definitions, parentPath = "") {
+    for (const def of definitions) {
+      if (def.$type === "VisualizerDef" && def.body) {
+        processDefinitions(def.body, parentPath);
+        continue;
+      }
+      if (def.$type === "DomainDef") {
+        const domainPath = nested ? `domains/${def.name}` : "";
+        const domainBody = def.body || [];
+        const domainServices = domainBody.filter((d) => d.$type === "ServiceDef");
+        processDefinitions(domainServices, domainPath);
+        const subdomains = domainBody.filter((d) => d.$type === "SubdomainDef");
+        for (const sub of subdomains) {
+          const subPath = nested ? `domains/${def.name}/subdomains/${sub.name}` : "";
+          const subServices = (sub.body || []).filter((d) => d.$type === "ServiceDef");
+          processDefinitions(subServices, subPath);
+        }
+        continue;
+      }
+      if (def.$type !== "ServiceDef") continue;
+      const servicePath = nested ? parentPath ? `${parentPath}/services/${def.name}` : `services/${def.name}` : "";
+      const body = def.body || [];
+      for (const stmt of body) {
+        if (stmt.$type === "SendsStmt" || stmt.$type === "ReceivesStmt") {
+          const msgType = stmt.messageType;
+          const msgName = stmt.messageName;
+          const hasBody = stmt.body && stmt.body.length > 0;
+          const version2 = stmt.version || DEFAULT_STUB_VERSION;
+          if (!hasBody) {
+            const folder = MESSAGE_TYPE_FOLDER[msgType];
+            if (folder) {
+              const key = getResourceVersionKey(msgType, msgName, version2);
+              const anyVersionKey = getResourceNameKey(msgType, msgName);
+              if (!compiledIds.has(key) && !stubIds.has(key) && !(!stmt.version && compiledIds.has(anyVersionKey))) {
+                const stubFolder = nested && servicePath ? `${servicePath}/${folder}` : folder;
+                stubIds.add(key);
+                stubs.push({
+                  type: msgType,
+                  id: msgName,
+                  version: version2,
+                  frontmatter: {
+                    id: msgName,
+                    name: msgName,
+                    version: version2
+                  },
+                  markdown: "",
+                  path: `${stubFolder}/${msgName}/versioned/${version2}/index.md`
+                });
+              }
+            }
+          }
+          if (stmt.channelClause) {
+            const channels = stmt.channelClause.channels || [];
+            for (const ch of channels) {
+              const chName = ch.channelName;
+              const chVersion = ch.channelVersion || DEFAULT_STUB_VERSION;
+              const chKey = getResourceVersionKey("channel", chName, chVersion);
+              const chAnyVersionKey = getResourceNameKey("channel", chName);
+              if (compiledIds.has(chKey) || stubIds.has(chKey)) continue;
+              if (!ch.channelVersion && compiledIds.has(chAnyVersionKey)) continue;
+              const chFolder = nested && parentPath ? `${parentPath}/channels` : "channels";
+              stubIds.add(chKey);
+              stubs.push({
+                type: "channel",
+                id: chName,
+                version: chVersion,
+                frontmatter: {
+                  id: chName,
+                  name: chName,
+                  version: chVersion
+                },
+                markdown: "",
+                path: `${chFolder}/${chName}/versioned/${chVersion}/index.md`
+              });
+            }
+          }
+          continue;
+        }
+        if (stmt.$type === "WritesToStmt" || stmt.$type === "ReadsFromStmt") {
+          const containerName = stmt.ref?.name;
+          if (!containerName) continue;
+          const containerVersion = stmt.ref?.version || DEFAULT_STUB_VERSION;
+          const containerKey = getResourceVersionKey("container", containerName, containerVersion);
+          const containerAnyVersionKey = getResourceNameKey("container", containerName);
+          if (compiledIds.has(containerKey) || stubIds.has(containerKey)) continue;
+          if (!stmt.ref?.version && compiledIds.has(containerAnyVersionKey)) continue;
+          const containerFolder = nested && parentPath ? `${parentPath}/containers` : "containers";
+          stubIds.add(containerKey);
+          stubs.push({
+            type: "container",
+            id: containerName,
+            version: containerVersion,
+            frontmatter: {
+              id: containerName,
+              name: containerName,
+              version: containerVersion
+            },
+            markdown: "",
+            path: `${containerFolder}/${containerName}/versioned/${containerVersion}/index.md`
+          });
+        }
+      }
+    }
+  }
+  processDefinitions(program2.definitions);
+  return stubs;
+}
+function getVersionFromBody(body) {
+  if (!body) return void 0;
+  const versionStmt = body.find((stmt) => stmt?.$type === "VersionStmt");
+  return versionStmt?.value;
+}
+function buildServiceOutputPath(serviceName, body, nested, parentPath) {
+  const folder = nested && parentPath ? `${parentPath}/services` : "services";
+  const version2 = getVersionFromBody(body);
+  if (version2) return `${folder}/${serviceName}/versioned/${version2}/index.md`;
+  return `${folder}/${serviceName}/index.md`;
+}
+function extractServiceContainerRefs(program2, nested = false) {
+  const refsByPath = /* @__PURE__ */ new Map();
+  function processDefinitions(definitions, parentPath = "") {
+    for (const def of definitions || []) {
+      if (def.$type === "VisualizerDef" && def.body) {
+        processDefinitions(def.body, parentPath);
+        continue;
+      }
+      if (def.$type === "DomainDef") {
+        const domainPath = nested ? `domains/${def.name}` : "";
+        const domainBody = def.body || [];
+        const domainServices = domainBody.filter((d) => d.$type === "ServiceDef");
+        processDefinitions(domainServices, domainPath);
+        const subdomains = domainBody.filter((d) => d.$type === "SubdomainDef");
+        for (const sub of subdomains) {
+          const subPath = nested ? `domains/${def.name}/subdomains/${sub.name}` : "";
+          const subServices = (sub.body || []).filter((d) => d.$type === "ServiceDef");
+          processDefinitions(subServices, subPath);
+        }
+        continue;
+      }
+      if (def.$type !== "ServiceDef") continue;
+      const body = def.body || [];
+      const writesTo = body.filter((stmt) => stmt.$type === "WritesToStmt" && stmt.ref?.name).map((stmt) => ({
+        id: stmt.ref.name,
+        ...stmt.ref.version ? { version: stmt.ref.version } : {}
+      }));
+      const readsFrom = body.filter((stmt) => stmt.$type === "ReadsFromStmt" && stmt.ref?.name).map((stmt) => ({
+        id: stmt.ref.name,
+        ...stmt.ref.version ? { version: stmt.ref.version } : {}
+      }));
+      if (writesTo.length === 0 && readsFrom.length === 0) continue;
+      const path2 = buildServiceOutputPath(def.name, body, nested, parentPath);
+      refsByPath.set(path2, {
+        ...writesTo.length > 0 ? { writesTo } : {},
+        ...readsFrom.length > 0 ? { readsFrom } : {}
+      });
+    }
+  }
+  processDefinitions(program2.definitions || []);
+  return refsByPath;
+}
+var SDK_WRITER_BASE = {
+  event: "events",
+  command: "commands",
+  query: "queries",
+  service: "services",
+  domain: "domains",
+  channel: "channels",
+  container: "containers",
+  dataProduct: "data-products",
+  diagram: "diagrams",
+  team: "teams",
+  user: "users"
+};
+function extractSdkPath(compiledPath, resourceType) {
+  const dirPath = compiledPath.replace(/\/versioned\/[^/]+\/index\.md$/, "").replace(/\/index\.md$/, "").replace(/\.md$/, "");
+  const baseFolder = SDK_WRITER_BASE[resourceType];
+  if (!baseFolder) return "";
+  if (dirPath.startsWith(`${baseFolder}/`)) {
+    const relative = dirPath.slice(baseFolder.length + 1);
+    if (!relative.includes("/")) return "";
+    return relative;
+  }
+  return `../${dirPath}`;
+}
+var TYPES_WITH_NODE_GRAPH = /* @__PURE__ */ new Set(["event", "command", "query", "service", "domain", "channel", "flow"]);
+function getWriter(sdk, type) {
+  switch (type) {
+    case "event":
+      return sdk.writeEvent;
+    case "command":
+      return sdk.writeCommand;
+    case "query":
+      return sdk.writeQuery;
+    case "service":
+      return sdk.writeService;
+    case "domain":
+      return sdk.writeDomain;
+    case "channel":
+      return sdk.writeChannel;
+    case "container":
+      return sdk.writeDataStore;
+    case "dataProduct":
+      return sdk.writeDataProduct;
+    case "diagram":
+      return sdk.writeDiagram;
+    case "team":
+      return sdk.writeTeam;
+    case "user":
+      return sdk.writeUser;
+    default:
+      return null;
+  }
+}
+function getReader(sdk, type) {
+  switch (type) {
+    case "event":
+      return sdk.getEvent;
+    case "command":
+      return sdk.getCommand;
+    case "query":
+      return sdk.getQuery;
+    case "service":
+      return sdk.getService;
+    case "domain":
+      return sdk.getDomain;
+    case "channel":
+      return sdk.getChannel;
+    case "container":
+      return sdk.getDataStore;
+    case "dataProduct":
+      return sdk.getDataProduct;
+    case "diagram":
+      return sdk.getDiagram;
+    case "team":
+      return sdk.getTeam;
+    case "user":
+      return sdk.getUser;
+    default:
+      return null;
+  }
+}
+function promptConfirm(message) {
+  return new Promise((resolve4) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`${message} `, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve4(normalized === "" || normalized === "y" || normalized === "yes");
+    });
+  });
+}
+function promptInput(message, defaultValue) {
+  return new Promise((resolve4) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`${message} `, (answer) => {
+      rl.close();
+      resolve4(answer.trim() || defaultValue);
+    });
+  });
+}
+function initCatalog(dir, organizationName = "My Organization") {
+  const catalogDir = resolve2(dir);
+  mkdirSync(catalogDir, { recursive: true });
+  const packageJson = {
+    name: "my-catalog",
+    version: "0.1.0",
+    private: true,
+    scripts: {
+      dev: "eventcatalog dev",
+      build: "eventcatalog build",
+      start: "eventcatalog start",
+      preview: "eventcatalog preview",
+      generate: "eventcatalog generate",
+      lint: "eventcatalog-linter",
+      test: 'echo "Error: no test specified" && exit 1'
+    },
+    dependencies: {
+      "@eventcatalog/core": "latest",
+      "@eventcatalog/linter": "latest"
+    }
+  };
+  writeFileSync2(join(catalogDir, "package.json"), JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+  const cId = randomUUID();
+  const config = `/** @type {import('@eventcatalog/core/bin/eventcatalog.config').Config} */
+export default {
+  title: 'EventCatalog',
+  tagline: 'Discover, Explore and Document your Event Driven Architectures',
+  organizationName: '${organizationName}',
+  homepageLink: 'https://eventcatalog.dev/',
+  output: 'static',
+  trailingSlash: false,
+  base: '/',
+  logo: {
+    alt: 'EventCatalog Logo',
+    src: '/logo.png',
+    text: 'EventCatalog',
+  },
+  cId: '${cId}',
+};
+`;
+  writeFileSync2(join(catalogDir, "eventcatalog.config.js"), config, "utf-8");
+  const gitignore = `# Dependencies
+/node_modules
+
+# Production
+/build
+
+# Generated files
+.astro
+out
+dist
+
+# Misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+.eventcatalog-core
+
+.env
+.env-*
+`;
+  writeFileSync2(join(catalogDir, ".gitignore"), gitignore, "utf-8");
+  const envFile = `# EventCatalog Scale License Key, if you want to unlock the scale features
+# You can get a 14 day trial license key from https://eventcatalog.cloud
+
+EVENTCATALOG_SCALE_LICENSE_KEY=
+
+# Optional key if you are using EventCatalog Chat with OpenAI Models.
+# You need to set \`output\` to \`server\` in your eventcatalog.config.js file.
+# See documentation for more details: https://www.eventcatalog.dev/features/ai-assistant
+OPENAI_API_KEY=
+`;
+  writeFileSync2(join(catalogDir, ".env"), envFile, "utf-8");
+  writeFileSync2(join(catalogDir, ".npmrc"), "strict-peer-dependencies=false\n", "utf-8");
+  mkdirSync(join(catalogDir, "public"), { recursive: true });
+  copyFileSync(join(__dirname, "logo.png"), join(catalogDir, "public", "logo.png"));
+}
+async function importDSL(options) {
+  const { files, stdin = false, dryRun = false, flat = false, noInit = false, dir } = options;
+  const nested = !flat;
+  let source;
+  if (stdin) {
+    source = await readStdin();
+  } else if (files && files.length > 0) {
+    const parts = [];
+    for (const file of files) {
+      const filepath = resolve2(file);
+      if (!existsSync2(filepath)) {
+        throw new Error(`File not found: ${filepath}`);
+      }
+      parts.push(readFileSync(filepath, "utf-8"));
+    }
+    source = parts.join("\n\n");
+  } else {
+    throw new Error("Either provide .ec file paths or use --stdin");
+  }
+  if (!source.trim()) {
+    throw new Error("No DSL content to import");
+  }
+  const catalogDir = resolve2(dir);
+  let didInit = false;
+  if (!noInit && !existsSync2(join(catalogDir, "eventcatalog.config.js")) && process.stdin.isTTY) {
+    const confirmed = await promptConfirm(`Initialize a new EventCatalog at ${catalogDir}? (Y/n)`);
+    if (confirmed) {
+      const organizationName = await promptInput("Organization name (My Organization):", "My Organization");
+      initCatalog(dir, organizationName);
+      didInit = true;
+    }
+  }
+  const parsed = await parseDSL(source, { nested });
+  const outputs = parsed.outputs;
+  if (outputs.length === 0) {
+    throw new Error("No resources found in DSL content");
+  }
+  const sdk = createSDK4(catalogDir);
+  const result = { created: [], updated: [], versioned: [], errors: [] };
+  const readerCache = /* @__PURE__ */ new Map();
+  const readResourceCached = async (reader, type, id, version2) => {
+    if (!reader) return void 0;
+    const cacheKey = getResourceVersionKey(type, id, version2);
+    if (!readerCache.has(cacheKey)) {
+      readerCache.set(
+        cacheKey,
+        reader(id, version2).catch(() => void 0)
+      );
+    }
+    return await readerCache.get(cacheKey);
+  };
+  const invalidateReaderCache = (type, id, version2) => {
+    readerCache.delete(getResourceVersionKey(type, id));
+    readerCache.delete(getResourceVersionKey(type, id, version2));
+  };
+  const resources = outputs.map(parseCompiledOutput);
+  const serviceContainerRefsByPath = extractServiceContainerRefs(parsed.program, nested);
+  for (const resource of resources) {
+    if (resource.type !== "service") continue;
+    const refs = serviceContainerRefsByPath.get(resource.path);
+    if (!refs) continue;
+    resource.frontmatter = {
+      ...resource.frontmatter,
+      ...refs
+    };
+  }
+  const compiledIds = /* @__PURE__ */ new Set();
+  for (const resource of resources) {
+    compiledIds.add(getResourceNameKey(resource.type, resource.id));
+    compiledIds.add(getResourceVersionKey(resource.type, resource.id, resource.version));
+  }
+  const stubs = hasReferenceStatements(source) ? await extractMessageStubs(parsed.program, compiledIds, nested) : [];
+  resources.push(...stubs);
+  for (const resource of resources) {
+    const label = resource.version ? `${resource.type} ${resource.id}@${resource.version}` : `${resource.type} ${resource.id}`;
+    if (dryRun) {
+      const reader = getReader(sdk, resource.type);
+      if (reader) {
+        const existing = await readResourceCached(reader, resource.type, resource.id, resource.version);
+        if (existing) {
+          result.updated.push(label);
+        } else {
+          const latest = await readResourceCached(reader, resource.type, resource.id);
+          if (latest && latest.version && latest.version !== resource.version) {
+            result.versioned.push(`${resource.type} ${resource.id}@${latest.version}`);
+          }
+          result.created.push(label);
+        }
+      } else {
+        result.created.push(label);
+      }
+      continue;
+    }
+    const writer = getWriter(sdk, resource.type);
+    if (!writer) {
+      result.errors.push(`${label}: unsupported resource type '${resource.type}'`);
+      continue;
+    }
+    try {
+      const reader = getReader(sdk, resource.type);
+      const existing = await readResourceCached(reader, resource.type, resource.id, resource.version);
+      const latest = !existing && resource.version ? await readResourceCached(reader, resource.type, resource.id) : void 0;
+      const versionedFrom = !existing && resource.version && latest?.version && latest.version !== resource.version ? latest.version : void 0;
+      const incomingMarkdown = resource.markdown;
+      const hasIncomingMarkdown = incomingMarkdown.trim().length > 0;
+      let markdown = incomingMarkdown;
+      if (!hasIncomingMarkdown) {
+        if (existing?.markdown) {
+          markdown = existing.markdown;
+        } else if (!existing && latest?.markdown) {
+          markdown = latest.markdown;
+        }
+      }
+      if (!existing && TYPES_WITH_NODE_GRAPH.has(resource.type)) {
+        if (!markdown) {
+          markdown = "<NodeGraph />";
+        } else if (!markdown.includes("<NodeGraph />")) {
+          markdown = `${markdown}
+
+<NodeGraph />`;
+        }
+      }
+      const resourceData = {
+        ...normalizeImportedFrontmatter(resource.type, resource.frontmatter),
+        markdown
+      };
+      const writeOptions = {
+        override: true,
+        versionExistingContent: Boolean(versionedFrom)
+      };
+      if (!existing && nested) {
+        const sdkPath = extractSdkPath(resource.path, resource.type);
+        if (sdkPath) {
+          writeOptions.path = sdkPath;
+        }
+      }
+      await writer(resourceData, writeOptions);
+      invalidateReaderCache(resource.type, resource.id, resource.version);
+      if (existing) {
+        result.updated.push(label);
+      } else {
+        result.created.push(label);
+        if (versionedFrom) {
+          result.versioned.push(`${resource.type} ${resource.id}@${versionedFrom}`);
+        }
+      }
+    } catch (error) {
+      result.errors.push(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  let output = formatResult(result, dryRun);
+  if (didInit) {
+    output += `  Tip: Run 'npm install' in ${catalogDir} to install dependencies
+`;
+  }
+  return output;
+}
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  red: "\x1B[31m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var TYPE_CONFIG = {
+  domain: { color: c.magenta, label: "domain", order: 0 },
+  service: { color: c.blue, label: "service", order: 1 },
+  event: { color: c.green, label: "event", order: 2 },
+  command: { color: c.yellow, label: "command", order: 3 },
+  query: { color: c.cyan, label: "query", order: 4 },
+  channel: { color: c.gray, label: "channel", order: 5 },
+  flow: { color: c.white, label: "flow", order: 6 },
+  container: { color: c.white, label: "container", order: 7 },
+  dataProduct: { color: c.white, label: "data product", order: 8 },
+  diagram: { color: c.white, label: "diagram", order: 9 },
+  user: { color: c.blue, label: "user", order: 10 },
+  team: { color: c.blue, label: "team", order: 11 }
+};
+var DEFAULT_TYPE_CONFIG = { color: c.white, label: "resource", order: 99 };
+function parseLabel(label) {
+  const spaceIdx = label.indexOf(" ");
+  if (spaceIdx === -1) return { type: "", name: label };
+  return { type: label.slice(0, spaceIdx), name: label.slice(spaceIdx + 1) };
+}
+function groupByType(labels) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const label of labels) {
+    const { type, name } = parseLabel(label);
+    if (!groups.has(type)) groups.set(type, []);
+    groups.get(type).push(name);
+  }
+  const sorted = new Map(
+    [...groups.entries()].sort((a, b) => {
+      const orderA = (TYPE_CONFIG[a[0]] || DEFAULT_TYPE_CONFIG).order;
+      const orderB = (TYPE_CONFIG[b[0]] || DEFAULT_TYPE_CONFIG).order;
+      return orderA - orderB;
+    })
+  );
+  for (const [, names] of sorted) {
+    names.sort();
+  }
+  return sorted;
+}
+function typeBadge(type) {
+  const cfg = TYPE_CONFIG[type] || DEFAULT_TYPE_CONFIG;
+  const padded = ` ${cfg.label} `;
+  return `${cfg.color}\x1B[7m${padded}${c.reset}`;
+}
+function formatResourceList(labels) {
+  const lines = [];
+  const groups = groupByType(labels);
+  for (const [type, names] of groups) {
+    const cfg = TYPE_CONFIG[type] || DEFAULT_TYPE_CONFIG;
+    const plural = names.length === 1 ? cfg.label : `${cfg.label}s`;
+    lines.push("");
+    lines.push(`   ${typeBadge(type)} ${c.dim}${names.length} ${plural}${c.reset}`);
+    for (const name of names) {
+      lines.push(`   ${cfg.color}\u2502${c.reset}  ${name}`);
+    }
+  }
+  return lines;
+}
+function formatResult(result, dryRun) {
+  const lines = [""];
+  const prefix = dryRun ? `${c.yellow}${c.bold}DRY RUN${c.reset} ` : "";
+  const total = result.created.length + result.updated.length + result.versioned.length;
+  if (total > 0 || result.errors.length > 0) {
+    lines.push(`  ${prefix}${c.bold}Import complete${c.reset}`);
+    lines.push(`  ${c.dim}${"\u2500".repeat(40)}${c.reset}`);
+  }
+  if (result.created.length > 0) {
+    const verb = dryRun ? "Would create" : "Created";
+    lines.push("");
+    lines.push(`  ${c.green}${c.bold}+ ${verb} ${result.created.length} resource(s)${c.reset}`);
+    lines.push(...formatResourceList(result.created));
+  }
+  if (result.updated.length > 0) {
+    const verb = dryRun ? "Would update" : "Updated";
+    lines.push("");
+    lines.push(`  ${c.blue}${c.bold}~ ${verb} ${result.updated.length} resource(s)${c.reset}`);
+    lines.push(...formatResourceList(result.updated));
+  }
+  if (result.versioned.length > 0) {
+    const verb = dryRun ? "Would version" : "Versioned";
+    lines.push("");
+    lines.push(`  ${c.yellow}${c.bold}\u2191 ${verb} ${result.versioned.length} existing resource(s)${c.reset}`);
+    lines.push(...formatResourceList(result.versioned));
+  }
+  if (result.errors.length > 0) {
+    lines.push("");
+    lines.push(`  ${c.red}${c.bold}\u2718 ${result.errors.length} error(s)${c.reset}`);
+    for (const e of result.errors) {
+      lines.push(`   ${c.red}\u2502${c.reset}  ${c.red}${e}${c.reset}`);
+    }
+  }
+  if (result.created.length === 0 && result.updated.length === 0 && result.errors.length === 0) {
+    lines.push(`  ${c.dim}No resources to write.${c.reset}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function readStdin() {
+  return new Promise((resolve4, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve4(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("error", reject);
+  });
+}
+
 // src/cli/index.ts
 var version = "1.0.0";
 try {
-  const packageJsonPath = resolve2(__dirname, "../../package.json");
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const packageJsonPath = resolve3(__dirname, "../../package.json");
+  const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
   version = packageJson.version;
 } catch {
 }
@@ -355,7 +1101,7 @@ program.command("list").description("List all available SDK functions").action((
     process.exit(1);
   }
 });
-program.command("export").description("Export a catalog resource to EventCatalog DSL (.ec) format").option("-a, --all", "Export the entire catalog (all resource types)", false).option("-r, --resource <type>", "Resource type (event, command, query, service, domain)").option("--id <id>", "Resource ID (omit to export all resources of the given type)").option("-v, --version <version>", "Resource version (defaults to latest)").option("--hydrate", "Include referenced resources (messages, channels, owners)", false).option("--stdout", "Print to stdout instead of writing a file", false).option("--playground", "Open the exported DSL in the playground", false).option("-o, --output <path>", "Output file path (defaults to <id>.ec or catalog.ec)").action(async (opts) => {
+program.command("export").description("Export a catalog resource to EventCatalog DSL (.ec) format").option("-a, --all", "Export the entire catalog (all resource types)", false).option("-r, --resource <type>", "Resource type (event, command, query, service, domain)").option("--id <id>", "Resource ID (omit to export all resources of the given type)").option("-v, --version <version>", "Resource version (defaults to latest)").option("--hydrate", "Include referenced resources (messages, channels, owners)", false).option("--stdout", "Print to stdout instead of writing a file", false).option("--playground", "Open the exported DSL in EventCatalog Modelling", false).option("-o, --output <path>", "Output file path (defaults to <id>.ec or catalog.ec)").action(async (opts) => {
   try {
     const globalOpts = program.opts();
     const dir = globalOpts.dir || ".";
@@ -390,6 +1136,24 @@ program.command("export").description("Export a catalog resource to EventCatalog
     process.exit(1);
   }
 });
+program.command("import [files...]").description("Import EventCatalog DSL (.ec) files into catalog markdown").option("--stdin", "Read DSL from stdin", false).option("--dry-run", "Preview resources without writing", false).option("--flat", "Write resources in flat structure (no nesting under domains/services)", false).option("--no-init", "Skip catalog initialization prompt").action(async (files, opts) => {
+  try {
+    const globalOpts = program.opts();
+    const dir = globalOpts.dir || ".";
+    const result = await importDSL({
+      files: files.length > 0 ? files : void 0,
+      stdin: opts.stdin,
+      dryRun: opts.dryRun,
+      flat: opts.flat,
+      noInit: !opts.init,
+      dir
+    });
+    console.log(result);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
 program.arguments("<function> [args...]").action(async (functionName, args) => {
   try {
     const options = program.opts();