@eventcatalog/linter 1.0.1 → 1.0.3

package/dist/cli/index.js

@@ -0,0 +1,1343 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/index.ts
+var import_commander = require("commander");
+var import_chalk2 = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+var import_path3 = __toESM(require("path"));
+
+// src/scanner/index.ts
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_path = __toESM(require("path"));
+var RESOURCE_PATTERNS = {
+  domain: [
+    "domains/*/index.{md,mdx}",
+    "domains/*/versioned/*/index.{md,mdx}",
+    "domains/*/subdomains/*/index.{md,mdx}",
+    "domains/*/subdomains/*/versioned/*/index.{md,mdx}"
+  ],
+  service: [
+    "domains/*/services/*/index.{md,mdx}",
+    "domains/*/services/*/versioned/*/index.{md,mdx}",
+    "domains/*/subdomains/*/services/*/index.{md,mdx}",
+    "domains/*/subdomains/*/services/*/versioned/*/index.{md,mdx}",
+    "services/*/index.{md,mdx}",
+    "services/*/versioned/*/index.{md,mdx}"
+  ],
+  event: ["**/events/*/index.{md,mdx}", "**/events/*/versioned/*/index.{md,mdx}"],
+  command: ["**/commands/*/index.{md,mdx}", "**/commands/*/versioned/*/index.{md,mdx}"],
+  query: ["**/queries/*/index.{md,mdx}", "**/queries/*/versioned/*/index.{md,mdx}"],
+  channel: ["**/channels/*/index.{md,mdx}", "**/channels/*/versioned/*/index.{md,mdx}"],
+  flow: ["**/flows/*/index.{md,mdx}", "**/flows/*/versioned/*/index.{md,mdx}"],
+  entity: ["**/entities/*/index.{md,mdx}", "**/entities/*/versioned/*/index.{md,mdx}"],
+  user: ["users/*.{md,mdx}"],
+  team: ["teams/*.{md,mdx}"],
+  dataStore: ["**/containers/*/index.{md,mdx}", "**/containers/*/versioned/*/index.{md,mdx}"]
+};
+var extractResourceInfo = (filePath, resourceType) => {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const relativePath = normalizedPath.split("/");
+  if (resourceType === "user" || resourceType === "team") {
+    const filename = import_path.default.basename(filePath, import_path.default.extname(filePath));
+    return { id: filename };
+  }
+  const resourceTypePattern = `${resourceType}s`;
+  const resourceTypeIndex = relativePath.findIndex((part) => part === resourceTypePattern);
+  if (resourceTypeIndex === -1) {
+    const parts2 = relativePath.slice(1, -1);
+    return { id: parts2[parts2.length - 1] };
+  }
+  const parts = relativePath.slice(resourceTypeIndex + 1, -1);
+  if (parts.length === 0) {
+    return { id: "unknown" };
+  }
+  if (parts.length >= 3 && parts[parts.length - 2] === "versioned") {
+    const version = parts[parts.length - 1];
+    const resourceId = parts.slice(0, -2).join("/");
+    return { id: resourceId, version };
+  }
+  if (resourceType === "domain" && parts.length >= 2) {
+    const versionedIndex = parts.findIndex((part) => part === "versioned");
+    if (versionedIndex !== -1 && versionedIndex < parts.length - 1) {
+      const version = parts[versionedIndex + 1];
+      const resourceId = parts.slice(0, versionedIndex).join("/");
+      return { id: resourceId, version };
+    }
+  }
+  if (parts.length === 1) {
+    return { id: parts[0] };
+  }
+  return { id: parts.join("/") };
+};
+var scanCatalogFiles = async (rootDir) => {
+  const files = [];
+  for (const [resourceType, patterns] of Object.entries(RESOURCE_PATTERNS)) {
+    const foundFiles = await (0, import_fast_glob.default)(patterns, {
+      cwd: rootDir,
+      absolute: true,
+      onlyFiles: true,
+      followSymbolicLinks: false
+    });
+    for (const filePath of foundFiles) {
+      const relativePath = import_path.default.relative(rootDir, filePath);
+      const { id, version } = extractResourceInfo(relativePath, resourceType);
+      files.push({
+        path: filePath,
+        relativePath,
+        resourceType,
+        resourceId: id,
+        version
+      });
+    }
+  }
+  return files;
+};
+
+// src/parser/index.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_gray_matter = __toESM(require("gray-matter"));
+var parseFrontmatter = async (file) => {
+  try {
+    const fileContent = await import_promises.default.readFile(file.path, "utf-8");
+    const { data, content } = (0, import_gray_matter.default)(fileContent);
+    return {
+      file,
+      frontmatter: data,
+      content,
+      raw: fileContent
+    };
+  } catch (error) {
+    return {
+      file,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+};
+var parseAllFiles = async (files) => {
+  const results = await Promise.all(files.map(parseFrontmatter));
+  const parsed = [];
+  const errors = [];
+  for (const result of results) {
+    if ("error" in result) {
+      errors.push(result);
+    } else {
+      parsed.push(result);
+    }
+  }
+  return { parsed, errors };
+};
+
+// src/validators/schema-validator.ts
+var import_zod11 = require("zod");
+
+// src/schemas/common.ts
+var import_zod = require("zod");
+var badgeSchema = import_zod.z.object({
+  content: import_zod.z.string(),
+  backgroundColor: import_zod.z.string(),
+  textColor: import_zod.z.string(),
+  icon: import_zod.z.string().optional()
+});
+var ownerReferenceSchema = import_zod.z.union([
+  // The ID of the user or team
+  import_zod.z.string(),
+  // The full object with the ID and collection (keep compatibility with `reference`)
+  import_zod.z.object({
+    id: import_zod.z.string(),
+    collection: import_zod.z.enum(["users", "teams"])
+  })
+]).transform(
+  // This transformation is needed to keep compatibility with `reference`.
+  // The utilities `getTeams` and `getUsers` rely on this transformation.
+  (lookup) => ({ id: typeof lookup === "string" ? lookup : lookup.id })
+);
+var specificationSchema = import_zod.z.union([
+  import_zod.z.object({
+    openapiPath: import_zod.z.string().optional(),
+    asyncapiPath: import_zod.z.string().optional()
+  }),
+  import_zod.z.array(
+    import_zod.z.object({
+      type: import_zod.z.enum(["openapi", "asyncapi"]),
+      path: import_zod.z.string(),
+      name: import_zod.z.string().optional()
+    })
+  )
+]);
+var repositorySchema = import_zod.z.object({
+  language: import_zod.z.string().optional(),
+  url: import_zod.z.string().optional()
+});
+var draftSchema = import_zod.z.union([
+  import_zod.z.boolean(),
+  import_zod.z.object({
+    title: import_zod.z.string().optional(),
+    message: import_zod.z.string()
+  })
+]);
+var deprecatedSchema = import_zod.z.union([
+  import_zod.z.object({
+    message: import_zod.z.string().optional(),
+    date: import_zod.z.union([import_zod.z.string(), import_zod.z.date()]).optional()
+  }),
+  import_zod.z.boolean().optional()
+]);
+var pointerSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  version: import_zod.z.string().optional().default("latest")
+});
+var resourcePointerSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  version: import_zod.z.string().optional().default("latest"),
+  type: import_zod.z.enum(["service", "event", "command", "query", "flow", "channel", "domain", "user", "team"])
+});
+var channelPointerSchema = import_zod.z.object({
+  parameters: import_zod.z.record(import_zod.z.string()).optional()
+}).merge(pointerSchema);
+var semverSchema = import_zod.z.string().refine((version) => {
+  if (version === "latest") return true;
+  if (version.includes(".x")) {
+    const xPattern = /^\d+(\.\d+)*\.x$/;
+    return xPattern.test(version);
+  }
+  if (version.startsWith("^") || version.startsWith("~")) {
+    const rangeVersion = version.substring(1);
+    const semverRegex2 = /^\d+\.\d+\.\d+(-[\w\d-.]+)?(\+[\w\d-.]+)?$/;
+    return semverRegex2.test(rangeVersion);
+  }
+  const semverRegex = /^\d+\.\d+\.\d+(-[\w\d-.]+)?(\+[\w\d-.]+)?$/;
+  return semverRegex.test(version);
+}, "Invalid semantic version format");
+var sidebarSchema = import_zod.z.object({
+  label: import_zod.z.string().optional(),
+  badge: import_zod.z.string().optional()
+}).optional();
+var stylesSchema = import_zod.z.object({
+  icon: import_zod.z.string().optional(),
+  node: import_zod.z.object({
+    color: import_zod.z.string().optional(),
+    label: import_zod.z.string().optional()
+  }).optional()
+}).optional();
+var resourceGroupSchema = import_zod.z.array(
+  import_zod.z.object({
+    id: import_zod.z.string().optional(),
+    title: import_zod.z.string().optional(),
+    items: import_zod.z.array(resourcePointerSchema),
+    limit: import_zod.z.number().optional().default(10),
+    sidebar: import_zod.z.boolean().optional().default(true)
+  })
+).optional();
+var catalogMetadataSchema = import_zod.z.object({
+  path: import_zod.z.string(),
+  filePath: import_zod.z.string(),
+  astroContentFilePath: import_zod.z.string(),
+  publicPath: import_zod.z.string(),
+  type: import_zod.z.string()
+}).optional();
+var baseSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  name: import_zod.z.string(),
+  summary: import_zod.z.string().optional(),
+  version: semverSchema,
+  draft: import_zod.z.union([import_zod.z.boolean(), import_zod.z.object({ title: import_zod.z.string().optional(), message: import_zod.z.string() })]).optional(),
+  badges: import_zod.z.array(badgeSchema).optional(),
+  owners: import_zod.z.array(ownerReferenceSchema).optional(),
+  schemaPath: import_zod.z.string().optional(),
+  sidebar: sidebarSchema,
+  repository: repositorySchema.optional(),
+  specifications: specificationSchema.optional(),
+  hidden: import_zod.z.boolean().optional(),
+  resourceGroups: resourceGroupSchema,
+  styles: stylesSchema,
+  deprecated: deprecatedSchema.optional(),
+  visualiser: import_zod.z.boolean().optional(),
+  versions: import_zod.z.array(import_zod.z.string()).optional(),
+  latestVersion: import_zod.z.string().optional(),
+  catalog: catalogMetadataSchema
+});
+
+// src/schemas/domain.ts
+var import_zod2 = require("zod");
+var domainSchema = import_zod2.z.object({
+  services: import_zod2.z.array(pointerSchema).optional(),
+  domains: import_zod2.z.array(pointerSchema).optional(),
+  entities: import_zod2.z.array(pointerSchema).optional()
+}).merge(baseSchema);
+
+// src/schemas/service.ts
+var import_zod3 = require("zod");
+var serviceSchema = import_zod3.z.object({
+  sends: import_zod3.z.array(pointerSchema).optional(),
+  receives: import_zod3.z.array(pointerSchema).optional(),
+  entities: import_zod3.z.array(pointerSchema).optional(),
+  writesTo: import_zod3.z.array(pointerSchema).optional(),
+  readsFrom: import_zod3.z.array(pointerSchema).optional()
+}).merge(baseSchema);
+
+// src/schemas/message.ts
+var import_zod4 = require("zod");
+var baseMessageSchema = import_zod4.z.object({
+  producers: import_zod4.z.array(import_zod4.z.any()).optional(),
+  // reference('services')
+  consumers: import_zod4.z.array(import_zod4.z.any()).optional(),
+  // reference('services')
+  channels: import_zod4.z.array(channelPointerSchema).optional(),
+  messageChannels: import_zod4.z.array(import_zod4.z.any()).optional()
+  // reference('channels')
+}).merge(baseSchema);
+var eventSchema = baseMessageSchema;
+var commandSchema = baseMessageSchema;
+var querySchema = baseMessageSchema;
+
+// src/schemas/channel.ts
+var import_zod5 = require("zod");
+var parameterSchema = import_zod5.z.object({
+  enum: import_zod5.z.array(import_zod5.z.string()).optional(),
+  default: import_zod5.z.string().optional(),
+  examples: import_zod5.z.array(import_zod5.z.string()).optional(),
+  description: import_zod5.z.string().optional()
+});
+var channelSchema = import_zod5.z.object({
+  address: import_zod5.z.string().optional(),
+  protocols: import_zod5.z.array(import_zod5.z.string()).optional(),
+  parameters: import_zod5.z.record(parameterSchema).optional(),
+  messages: import_zod5.z.array(import_zod5.z.object({ collection: import_zod5.z.string(), name: import_zod5.z.string(), ...pointerSchema.shape })).optional()
+}).merge(baseSchema);
+
+// src/schemas/flow.ts
+var import_zod6 = require("zod");
+var flowStep = import_zod6.z.union([
+  import_zod6.z.union([import_zod6.z.string(), import_zod6.z.number()]),
+  import_zod6.z.object({
+    id: import_zod6.z.union([import_zod6.z.string(), import_zod6.z.number()]),
+    label: import_zod6.z.string().optional()
+  }).optional()
+]).optional();
+var flowStepSchema = import_zod6.z.object({
+  id: import_zod6.z.union([import_zod6.z.string(), import_zod6.z.number()]),
+  type: import_zod6.z.enum(["node", "message", "user", "actor"]).optional(),
+  title: import_zod6.z.string(),
+  summary: import_zod6.z.string().optional(),
+  message: pointerSchema.optional(),
+  service: pointerSchema.optional(),
+  flow: pointerSchema.optional(),
+  actor: import_zod6.z.object({
+    name: import_zod6.z.string()
+  }).optional(),
+  custom: import_zod6.z.object({
+    title: import_zod6.z.string(),
+    icon: import_zod6.z.string().optional(),
+    type: import_zod6.z.string().optional(),
+    summary: import_zod6.z.string().optional(),
+    url: import_zod6.z.string().url().optional(),
+    color: import_zod6.z.string().optional(),
+    properties: import_zod6.z.record(import_zod6.z.union([import_zod6.z.string(), import_zod6.z.number()])).optional(),
+    height: import_zod6.z.number().optional(),
+    menu: import_zod6.z.array(
+      import_zod6.z.object({
+        label: import_zod6.z.string(),
+        url: import_zod6.z.string().url().optional()
+      })
+    ).optional()
+  }).optional(),
+  externalSystem: import_zod6.z.object({
+    name: import_zod6.z.string(),
+    summary: import_zod6.z.string().optional(),
+    url: import_zod6.z.string().url().optional()
+  }).optional(),
+  next_step: flowStep,
+  next_steps: import_zod6.z.array(flowStep).optional()
+}).refine((data) => {
+  if (data.next_step && data.next_steps) return false;
+  const typesUsed = [data.message, data.service, data.flow, data.actor, data.custom].filter((v) => v).length;
+  return typesUsed === 0 || typesUsed === 1;
+});
+var flowSchema = import_zod6.z.object({
+  steps: import_zod6.z.array(flowStepSchema)
+}).merge(baseSchema);
+
+// src/schemas/entity.ts
+var import_zod7 = require("zod");
+var propertySchema = import_zod7.z.object({
+  name: import_zod7.z.string(),
+  type: import_zod7.z.string(),
+  required: import_zod7.z.boolean().optional(),
+  description: import_zod7.z.string().optional(),
+  references: import_zod7.z.string().optional(),
+  referencesIdentifier: import_zod7.z.string().optional(),
+  relationType: import_zod7.z.string().optional()
+});
+var entitySchema = import_zod7.z.object({
+  aggregateRoot: import_zod7.z.boolean().optional(),
+  identifier: import_zod7.z.string().optional(),
+  properties: import_zod7.z.array(propertySchema).optional(),
+  services: import_zod7.z.array(import_zod7.z.any()).optional(),
+  // reference('services')
+  domains: import_zod7.z.array(import_zod7.z.any()).optional()
+  // reference('domains')
+}).merge(baseSchema);
+
+// src/schemas/user.ts
+var import_zod8 = require("zod");
+var userSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  avatarUrl: import_zod8.z.string().optional(),
+  role: import_zod8.z.string().optional(),
+  hidden: import_zod8.z.boolean().optional(),
+  email: import_zod8.z.string().email().optional(),
+  slackDirectMessageUrl: import_zod8.z.string().optional(),
+  msTeamsDirectMessageUrl: import_zod8.z.string().optional(),
+  ownedDomains: import_zod8.z.array(import_zod8.z.any()).optional(),
+  // reference('domains')
+  ownedServices: import_zod8.z.array(import_zod8.z.any()).optional(),
+  // reference('services')
+  ownedEvents: import_zod8.z.array(import_zod8.z.any()).optional(),
+  // reference('events')
+  ownedCommands: import_zod8.z.array(import_zod8.z.any()).optional(),
+  // reference('commands')
+  ownedQueries: import_zod8.z.array(import_zod8.z.any()).optional(),
+  // reference('queries')
+  associatedTeams: import_zod8.z.array(import_zod8.z.any()).optional()
+  // reference('teams')
+});
+
+// src/schemas/team.ts
+var import_zod9 = require("zod");
+var teamSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  summary: import_zod9.z.string().optional(),
+  email: import_zod9.z.string().email().optional(),
+  hidden: import_zod9.z.boolean().optional(),
+  slackDirectMessageUrl: import_zod9.z.string().optional(),
+  msTeamsDirectMessageUrl: import_zod9.z.string().optional(),
+  members: import_zod9.z.array(import_zod9.z.any()).optional(),
+  // reference('users')
+  ownedCommands: import_zod9.z.array(import_zod9.z.any()).optional(),
+  // reference('commands')
+  ownedQueries: import_zod9.z.array(import_zod9.z.any()).optional(),
+  // reference('queries')
+  ownedDomains: import_zod9.z.array(import_zod9.z.any()).optional(),
+  // reference('domains')
+  ownedServices: import_zod9.z.array(import_zod9.z.any()).optional(),
+  // reference('services')
+  ownedEvents: import_zod9.z.array(import_zod9.z.any()).optional()
+  // reference('events')
+});
+
+// src/schemas/data-store.ts
+var import_zod10 = require("zod");
+var dataStoreSchema = import_zod10.z.object({
+  container_type: import_zod10.z.enum(["database", "cache", "objectStore", "searchIndex", "dataWarehouse", "dataLake", "externalSaaS"]),
+  technology: import_zod10.z.string().optional(),
+  authoritative: import_zod10.z.boolean().optional(),
+  access_mode: import_zod10.z.enum(["read", "write", "readWrite", "appendOnly"]),
+  classification: import_zod10.z.enum(["public", "internal", "confidential", "regulated"]),
+  residency: import_zod10.z.string().optional(),
+  retention: import_zod10.z.string().optional()
+}).merge(baseSchema);
+
+// src/schemas/index.ts
+var schemas = {
+  domain: domainSchema,
+  service: serviceSchema,
+  event: eventSchema,
+  command: commandSchema,
+  query: querySchema,
+  channel: channelSchema,
+  flow: flowSchema,
+  entity: entitySchema,
+  user: userSchema,
+  team: teamSchema,
+  dataStore: dataStoreSchema
+};
+
+// src/validators/schema-validator.ts
+var validateSchema = (parsedFile) => {
+  const { file, frontmatter } = parsedFile;
+  const schema = schemas[file.resourceType];
+  const errors = [];
+  try {
+    schema.parse(frontmatter);
+  } catch (error) {
+    if (error instanceof import_zod11.z.ZodError) {
+      for (const issue of error.issues) {
+        const field = issue.path.join(".");
+        let message = issue.message;
+        if (issue.code === "invalid_type") {
+          message = `Expected ${issue.expected}, but received ${issue.received}`;
+        }
+        let rule = "schema/required-fields";
+        if (issue.code === "invalid_type") {
+          rule = "schema/valid-type";
+        } else if (issue.code === "invalid_string" && issue.validation === "email") {
+          rule = "schema/valid-email";
+        } else if (field && field.includes("version")) {
+          rule = "schema/valid-semver";
+        }
+        errors.push({
+          type: "schema",
+          resource: `${file.resourceType}/${file.resourceId}`,
+          field: field || void 0,
+          message: field ? `${field}: ${message}` : message,
+          file: file.relativePath,
+          rule
+        });
+      }
+    } else {
+      errors.push({
+        type: "schema",
+        resource: `${file.resourceType}/${file.resourceId}`,
+        message: error instanceof Error ? error.message : String(error),
+        file: file.relativePath,
+        rule: "schema/validation-error"
+      });
+    }
+  }
+  return errors;
+};
+var validateAllSchemas = (parsedFiles) => {
+  const errors = [];
+  for (const parsedFile of parsedFiles) {
+    errors.push(...validateSchema(parsedFile));
+  }
+  return errors;
+};
+
+// src/validators/reference-validator.ts
+var import_semver = __toESM(require("semver"));
+var buildResourceIndex = (parsedFiles, dependencies) => {
+  const index = {};
+  for (const parsedFile of parsedFiles) {
+    const { file, frontmatter } = parsedFile;
+    const { resourceType } = file;
+    let resourceId = file.resourceId;
+    if (frontmatter.id && typeof frontmatter.id === "string") {
+      resourceId = frontmatter.id;
+    }
+    if (!index[resourceType]) {
+      index[resourceType] = {};
+    }
+    if (!index[resourceType][resourceId]) {
+      index[resourceType][resourceId] = /* @__PURE__ */ new Set();
+    }
+    if (frontmatter.version && typeof frontmatter.version === "string") {
+      index[resourceType][resourceId].add(frontmatter.version);
+    } else {
+      index[resourceType][resourceId].add("latest");
+    }
+  }
+  if (dependencies) {
+    for (const [resourceType, entries] of Object.entries(dependencies)) {
+      if (!index[resourceType]) {
+        index[resourceType] = {};
+      }
+      for (const entry of entries) {
+        if (!index[resourceType][entry.id]) {
+          index[resourceType][entry.id] = /* @__PURE__ */ new Set();
+        }
+        index[resourceType][entry.id].add(entry.version || "latest");
+      }
+    }
+  }
+  return index;
+};
+var checkResourceExists = (ref, resourceType, index) => {
+  const resourceVersions = index[resourceType]?.[ref.id];
+  if (!resourceVersions || resourceVersions.size === 0) {
+    return false;
+  }
+  if (!ref.version) {
+    return true;
+  }
+  const refVersion = ref.version === "latest" ? ref.version : ref.version;
+  const availableVersions = Array.from(resourceVersions);
+  if (refVersion === "latest") {
+    return availableVersions.includes("latest") || availableVersions.length > 0;
+  }
+  if (availableVersions.includes(refVersion)) {
+    return true;
+  }
+  try {
+    const semverVersions = availableVersions.filter((v) => v !== "latest" && import_semver.default.valid(v));
+    for (const availableVersion of semverVersions) {
+      if (import_semver.default.satisfies(availableVersion, refVersion)) {
+        return true;
+      }
+    }
+    if (refVersion.includes(".x")) {
+      const pattern = refVersion.replace(/\.x/g, "");
+      for (const availableVersion of semverVersions) {
+        if (availableVersion.startsWith(pattern)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch (error) {
+    return availableVersions.includes(refVersion);
+  }
+};
+var extractReferences = (parsedFile) => {
+  const { file, frontmatter } = parsedFile;
+  const references = [];
+  if (file.resourceType === "domain") {
+    if (frontmatter.services && Array.isArray(frontmatter.services)) {
+      frontmatter.services.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["service"], field: "services" });
+      });
+    }
+    if (frontmatter.domains && Array.isArray(frontmatter.domains)) {
+      frontmatter.domains.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["domain"], field: "domains" });
+      });
+    }
+    if (frontmatter.entities && Array.isArray(frontmatter.entities)) {
+      frontmatter.entities.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["entity"], field: "entities" });
+      });
+    }
+  }
+  if (file.resourceType === "service") {
+    if (frontmatter.sends && Array.isArray(frontmatter.sends)) {
+      frontmatter.sends.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["event", "command", "query"], field: "sends" });
+      });
+    }
+    if (frontmatter.receives && Array.isArray(frontmatter.receives)) {
+      frontmatter.receives.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["event", "command", "query"], field: "receives" });
+      });
+    }
+    if (frontmatter.entities && Array.isArray(frontmatter.entities)) {
+      frontmatter.entities.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["entity"], field: "entities" });
+      });
+    }
+    if (frontmatter.writesTo && Array.isArray(frontmatter.writesTo)) {
+      frontmatter.writesTo.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["dataStore"], field: "writesTo" });
+      });
+    }
+    if (frontmatter.readsFrom && Array.isArray(frontmatter.readsFrom)) {
+      frontmatter.readsFrom.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["dataStore"], field: "readsFrom" });
+      });
+    }
+  }
+  if (file.resourceType === "flow" && frontmatter.steps && Array.isArray(frontmatter.steps)) {
+    frontmatter.steps.forEach((step, index) => {
+      if (step.message) {
+        references.push({
+          ref: step.message,
+          possibleTypes: ["event", "command", "query"],
+          field: `steps[${index}].message`
+        });
+      }
+      if (step.service) {
+        references.push({ ref: step.service, possibleTypes: ["service"], field: `steps[${index}].service` });
+      }
+    });
+  }
+  if (file.resourceType === "entity" && frontmatter.properties && Array.isArray(frontmatter.properties)) {
+    frontmatter.properties.forEach((prop, index) => {
+      if (prop.references) {
+        references.push({
+          ref: { id: prop.references },
+          possibleTypes: ["entity"],
+          field: `properties[${index}].references`
+        });
+      }
+    });
+  }
+  if (frontmatter.owners && Array.isArray(frontmatter.owners)) {
+    frontmatter.owners.forEach((owner) => {
+      references.push({ ref: { id: owner }, possibleTypes: ["user", "team"], field: "owners" });
+    });
+  }
+  if (file.resourceType === "team" && frontmatter.members && Array.isArray(frontmatter.members)) {
+    frontmatter.members.forEach((member) => {
+      references.push({ ref: { id: member }, possibleTypes: ["user"], field: "members" });
+    });
+  }
+  return references;
+};
+var extractChannelReferences = (parsedFile) => {
+  const { file, frontmatter } = parsedFile;
+  const references = [];
+  if (file.resourceType !== "service" && file.resourceType !== "domain") {
+    return references;
+  }
+  const extractFromPointers = (pointers, parentField) => {
+    if (!Array.isArray(pointers)) return;
+    pointers.forEach((pointer, idx) => {
+      if (pointer.to && Array.isArray(pointer.to)) {
+        pointer.to.forEach((channelRef, cIdx) => {
+          if (channelRef && channelRef.id) {
+            references.push({
+              ref: { id: channelRef.id, version: channelRef.version },
+              possibleTypes: ["channel"],
+              field: `${parentField}[${idx}].to[${cIdx}]`
+            });
+          }
+        });
+      }
+      if (pointer.from && Array.isArray(pointer.from)) {
+        pointer.from.forEach((channelRef, cIdx) => {
+          if (channelRef && channelRef.id) {
+            references.push({
+              ref: { id: channelRef.id, version: channelRef.version },
+              possibleTypes: ["channel"],
+              field: `${parentField}[${idx}].from[${cIdx}]`
+            });
+          }
+        });
+      }
+    });
+  };
+  if (frontmatter.sends && Array.isArray(frontmatter.sends)) {
+    extractFromPointers(frontmatter.sends, "sends");
+  }
+  if (frontmatter.receives && Array.isArray(frontmatter.receives)) {
+    extractFromPointers(frontmatter.receives, "receives");
+  }
+  return references;
+};
+var validateReferences = (parsedFiles, dependencies) => {
+  const index = buildResourceIndex(parsedFiles, dependencies);
+  const errors = [];
+  for (const parsedFile of parsedFiles) {
+    const references = extractReferences(parsedFile);
+    for (const { ref, possibleTypes, field } of references) {
+      const found = possibleTypes.some((type) => checkResourceExists(ref, type, index));
+      if (!found) {
+        const versionStr = ref.version ? ` (version: ${ref.version})` : "";
+        const typeStr = possibleTypes.length === 1 ? possibleTypes[0] : possibleTypes.join("/");
+        let rule = "refs/resource-exists";
+        if (field === "owners") {
+          rule = "refs/owner-exists";
+        } else if (field === "writesTo" || field === "readsFrom") {
+          rule = "refs/container-exists";
+        } else if (ref.version) {
+          rule = "refs/valid-version-range";
+        }
+        errors.push({
+          type: "reference",
+          resource: `${parsedFile.file.resourceType}/${parsedFile.file.resourceId}`,
+          field,
+          message: `Referenced ${typeStr} "${ref.id}"${versionStr} does not exist`,
+          file: parsedFile.file.relativePath,
+          rule
+        });
+      }
+    }
+    const channelRefs = extractChannelReferences(parsedFile);
+    for (const { ref, possibleTypes, field } of channelRefs) {
+      const found = possibleTypes.some((type) => checkResourceExists(ref, type, index));
+      if (!found) {
+        const versionStr = ref.version ? ` (version: ${ref.version})` : "";
+        errors.push({
+          type: "reference",
+          resource: `${parsedFile.file.resourceType}/${parsedFile.file.resourceId}`,
+          field,
+          message: `Referenced channel "${ref.id}"${versionStr} does not exist`,
+          file: parsedFile.file.relativePath,
+          rule: "refs/channel-exists"
+        });
+      }
+    }
+  }
+  return errors;
+};
+var validateOrphanMessages = (parsedFiles, dependencies) => {
+  const errors = [];
+  const messageTypes = ["event", "command", "query"];
+  const messageFiles = parsedFiles.filter((pf) => messageTypes.includes(pf.file.resourceType));
+  if (messageFiles.length === 0) return errors;
+  const producedMessages = /* @__PURE__ */ new Set();
+  const consumedMessages = /* @__PURE__ */ new Set();
+  for (const parsedFile of parsedFiles) {
+    const { file, frontmatter } = parsedFile;
+    if (file.resourceType === "service" || file.resourceType === "domain") {
+      if (frontmatter.sends && Array.isArray(frontmatter.sends)) {
+        frontmatter.sends.forEach((ref) => {
+          if (ref && ref.id) producedMessages.add(ref.id);
+        });
+      }
+      if (frontmatter.receives && Array.isArray(frontmatter.receives)) {
+        frontmatter.receives.forEach((ref) => {
+          if (ref && ref.id) consumedMessages.add(ref.id);
+        });
+      }
+    }
+    if (messageTypes.includes(file.resourceType)) {
+      if (frontmatter.producers && Array.isArray(frontmatter.producers) && frontmatter.producers.length > 0) {
+        const msgId = frontmatter.id || file.resourceId;
+        producedMessages.add(msgId);
+      }
+      if (frontmatter.consumers && Array.isArray(frontmatter.consumers) && frontmatter.consumers.length > 0) {
+        const msgId = frontmatter.id || file.resourceId;
+        consumedMessages.add(msgId);
+      }
+    }
+  }
+  if (dependencies) {
+    for (const [type, entries] of Object.entries(dependencies)) {
+      if (messageTypes.includes(type)) {
+        entries.forEach((entry) => {
+          producedMessages.add(entry.id);
+          consumedMessages.add(entry.id);
+        });
+      }
+    }
+  }
+  for (const parsedFile of messageFiles) {
+    const msgId = parsedFile.frontmatter.id || parsedFile.file.resourceId;
+    const isProduced = producedMessages.has(msgId);
+    const isConsumed = consumedMessages.has(msgId);
+    if (!isProduced && !isConsumed) {
+      errors.push({
+        type: "reference",
+        resource: `${parsedFile.file.resourceType}/${parsedFile.file.resourceId}`,
+        field: "id",
+        message: `${parsedFile.file.resourceType} "${msgId}" has no producer and no consumer`,
+        file: parsedFile.file.relativePath,
+        rule: "refs/orphan-messages"
+      });
+    }
+  }
+  return errors;
+};
+var validateDeprecatedReferences = (parsedFiles) => {
+  const errors = [];
+  const deprecatedIndex = {};
+  for (const parsedFile of parsedFiles) {
+    const { file, frontmatter } = parsedFile;
+    if (frontmatter.deprecated && frontmatter.deprecated !== false) {
+      const resourceId = frontmatter.id || file.resourceId;
+      const key = `${file.resourceType}:${resourceId}`;
+      if (!deprecatedIndex[key]) {
+        deprecatedIndex[key] = /* @__PURE__ */ new Set();
+      }
+      if (frontmatter.version && typeof frontmatter.version === "string") {
+        deprecatedIndex[key].add(frontmatter.version);
+      } else {
+        deprecatedIndex[key].add("*");
+      }
+    }
+  }
+  if (Object.keys(deprecatedIndex).length === 0) return errors;
+  const isDeprecated = (type, id, version) => {
+    const key = `${type}:${id}`;
+    const versions = deprecatedIndex[key];
+    if (!versions) return false;
+    if (versions.has("*")) return true;
+    if (version && versions.has(version)) return true;
+    if (!version || version === "latest") return versions.size > 0;
+    return false;
+  };
+  for (const parsedFile of parsedFiles) {
+    const references = extractReferences(parsedFile);
+    for (const { ref, possibleTypes, field } of references) {
+      if (field === "owners" || field === "members") continue;
+      for (const type of possibleTypes) {
+        if (isDeprecated(type, ref.id, ref.version)) {
+          const versionStr = ref.version ? ` (version: ${ref.version})` : "";
+          errors.push({
+            type: "reference",
+            resource: `${parsedFile.file.resourceType}/${parsedFile.file.resourceId}`,
+            field,
+            message: `Referenced ${type} "${ref.id}"${versionStr} is deprecated`,
+            file: parsedFile.file.relativePath,
+            rule: "versions/no-deprecated-references"
+          });
+          break;
+        }
+      }
+    }
+  }
+  return errors;
+};
+var validateDuplicateResourceIds = (parsedFiles) => {
+  const errors = [];
+  const seen = {};
+  for (const parsedFile of parsedFiles) {
+    const { file, frontmatter } = parsedFile;
+    const resourceId = frontmatter.id || file.resourceId;
+    const version = frontmatter.version || "latest";
+    const key = `${file.resourceType}:${resourceId}:${version}`;
+    if (seen[key]) {
+      errors.push({
+        type: "reference",
+        resource: `${file.resourceType}/${file.resourceId}`,
+        field: "id",
+        message: `Duplicate ${file.resourceType} "${resourceId}" (version: ${version}) \u2014 also defined in ${seen[key]}`,
+        file: file.relativePath,
+        rule: "structure/duplicate-resource-ids"
+      });
+    } else {
+      seen[key] = file.relativePath;
+    }
+  }
+  return errors;
+};
+
+// src/validators/best-practices-validator.ts
+var validateBestPractices = (parsedFiles) => {
+  const errors = [];
+  for (const parsedFile of parsedFiles) {
+    const { file, frontmatter, content } = parsedFile;
+    if (!frontmatter.summary || typeof frontmatter.summary === "string" && frontmatter.summary.trim() === "") {
+      errors.push({
+        type: "schema",
+        resource: `${file.resourceType}/${file.resourceId}`,
+        field: "summary",
+        message: "Summary is required for better documentation",
+        file: file.relativePath,
+        severity: "error",
+        rule: "best-practices/summary-required"
+      });
+    }
+    if (file.resourceType !== "user" && file.resourceType !== "team" && (!frontmatter.owners || !Array.isArray(frontmatter.owners) || frontmatter.owners.length === 0)) {
+      errors.push({
+        type: "schema",
+        resource: `${file.resourceType}/${file.resourceId}`,
+        field: "owners",
+        message: "At least one owner is required",
+        file: file.relativePath,
+        severity: "error",
+        rule: "best-practices/owner-required"
+      });
+    }
+    if (!content || content.trim() === "") {
+      errors.push({
+        type: "schema",
+        resource: `${file.resourceType}/${file.resourceId}`,
+        field: "description",
+        message: "Resource should have a markdown description (body content) beyond just frontmatter",
+        file: file.relativePath,
+        severity: "warning",
+        rule: "best-practices/description-required"
+      });
+    }
+    if ((file.resourceType === "event" || file.resourceType === "command" || file.resourceType === "query") && !frontmatter.schemaPath) {
+      errors.push({
+        type: "schema",
+        resource: `${file.resourceType}/${file.resourceId}`,
+        field: "schemaPath",
+        message: `${file.resourceType} should have a schemaPath defined for consumers to understand the contract`,
+        file: file.relativePath,
+        severity: "warning",
+        rule: "best-practices/schema-required"
+      });
+    }
+  }
+  return errors;
+};
+
+// src/validators/index.ts
+var validateCatalog = (parsedFiles, dependencies) => {
+  const schemaErrors = validateAllSchemas(parsedFiles);
+  const referenceErrors = validateReferences(parsedFiles, dependencies);
+  const orphanErrors = validateOrphanMessages(parsedFiles, dependencies);
+  const deprecatedRefErrors = validateDeprecatedReferences(parsedFiles);
+  const duplicateErrors = validateDuplicateResourceIds(parsedFiles);
+  const bestPracticeErrors = validateBestPractices(parsedFiles);
+  return [
+    ...schemaErrors,
+    ...referenceErrors,
+    ...orphanErrors,
+    ...deprecatedRefErrors,
+    ...duplicateErrors,
+    ...bestPracticeErrors
+  ];
+};
+
+// src/reporters/index.ts
+var import_chalk = __toESM(require("chalk"));
+var formatError = (error, showFilename = true) => {
+  const lineInfo = error.line ? import_chalk.default.dim(`:${error.line}:1`) : "";
+  const filename = showFilename ? `${import_chalk.default.dim(error.file)}${lineInfo}` : "";
+  const isWarning = error.severity === "warning";
+  const severity = isWarning ? import_chalk.default.yellow("warning") : import_chalk.default.red("error");
+  const icon = isWarning ? import_chalk.default.yellow("\u26A0") : import_chalk.default.red("\u2716");
+  const errorCode = getErrorCode(error);
+  const field = error.field ? import_chalk.default.dim(`[${error.field}]`) : "";
+  const parts = [];
+  if (filename) parts.push(filename);
+  parts.push(icon, severity, error.message, field, import_chalk.default.dim(errorCode));
+  return parts.filter(Boolean).join(" ");
+};
+var getErrorCode = (error) => {
+  if (error.rule) {
+    return `(${error.rule})`;
+  }
+  if (error.type === "schema") {
+    if (error.field) {
+      if (error.message.includes("Required")) return "(@eventcatalog/required-field)";
+      if (error.message.includes("Expected")) return "(@eventcatalog/invalid-type)";
+      return "(@eventcatalog/schema-validation)";
+    }
+    return "(@eventcatalog/schema)";
+  }
+  if (error.type === "reference") {
+    return "(@eventcatalog/invalid-reference)";
+  }
+  return "(@eventcatalog/unknown)";
+};
+var formatParseError = (error, showFilename = true) => {
+  const filename = showFilename ? import_chalk.default.dim(error.file.relativePath) : "";
+  const severity = import_chalk.default.red("error");
+  const message = `Parse error: ${error.error.message}`;
+  const errorCode = import_chalk.default.dim("(@eventcatalog/parse-error)");
+  const parts = [];
+  if (filename) parts.push(filename);
+  parts.push(import_chalk.default.red("\u2716"), severity, message, errorCode);
+  return parts.filter(Boolean).join(" ");
+};
+var groupErrorsByFile = (errors) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    if (!grouped.has(error.file)) {
+      grouped.set(error.file, []);
+    }
+    grouped.get(error.file).push(error);
+  }
+  return grouped;
+};
+var reportErrors = (validationErrors, parseErrors, verbose = false) => {
+  const allErrors = [
+    ...validationErrors,
+    ...parseErrors.map((pe) => ({
+      type: "parse",
+      resource: pe.file.resourceType || "unknown",
+      message: pe.error.message,
+      file: pe.file.relativePath,
+      line: void 0
+    }))
+  ];
+  const schemaErrors = validationErrors.filter((e) => e.type === "schema");
+  const referenceErrors = validationErrors.filter((e) => e.type === "reference");
+  const warnings = validationErrors.filter((e) => e.severity === "warning");
+  const errors = [...validationErrors.filter((e) => e.severity !== "warning"), ...parseErrors];
+  const totalErrors = errors.length;
+  const totalWarnings = warnings.length;
+  if (totalErrors === 0 && totalWarnings === 0) {
+    console.log(import_chalk.default.green("\u2714 No problems found!"));
+    return {
+      totalErrors: 0,
+      totalWarnings: 0,
+      schemaErrors: 0,
+      referenceErrors: 0,
+      parseErrors: 0,
+      filesChecked: 0,
+      filesWithErrors: 0
+    };
+  }
+  const grouped = groupErrorsByFile(validationErrors);
+  const parseErrorsGrouped = groupParseErrorsByFile(parseErrors);
+  const allFiles = /* @__PURE__ */ new Set([...grouped.keys(), ...parseErrorsGrouped.keys()]);
+  console.log();
+  for (const file of Array.from(allFiles).sort()) {
+    const fileErrors = grouped.get(file) || [];
+    const fileParseErrors = parseErrorsGrouped.get(file) || [];
+    const fileErrorCount = fileErrors.length + fileParseErrors.length;
+    if (fileErrorCount === 0) continue;
+    console.log(import_chalk.default.underline(file));
+    for (const error of fileParseErrors) {
+      console.log(`  ${formatParseError(error, false)}`);
+    }
+    for (const error of fileErrors) {
+      console.log(`  ${formatError(error, false)}`);
+    }
+    const fileWarnings = fileErrors.filter((e) => e.severity === "warning").length;
+    const fileActualErrors = fileErrorCount - fileWarnings;
+    const problemText2 = fileErrorCount === 1 ? "problem" : "problems";
+    const summaryColor2 = fileActualErrors > 0 ? import_chalk.default.red : import_chalk.default.yellow;
+    const summaryIcon2 = fileActualErrors > 0 ? "\u2716" : "\u26A0";
+    console.log(summaryColor2(`
+${summaryIcon2} ${fileErrorCount} ${problemText2}
+`));
+  }
+  const filesWithErrors = allFiles.size;
+  const totalProblems = totalErrors + totalWarnings;
+  const problemText = totalProblems === 1 ? "problem" : "problems";
+  const fileText = filesWithErrors === 1 ? "file" : "files";
+  const summaryColor = totalErrors > 0 ? import_chalk.default.red.bold : import_chalk.default.yellow.bold;
+  const summaryIcon = totalErrors > 0 ? "\u2716" : "\u26A0";
+  console.log(summaryColor(`${summaryIcon} ${totalProblems} ${problemText} (${totalErrors} errors, ${totalWarnings} warnings)`));
+  console.log(import_chalk.default.dim(`  ${filesWithErrors} ${fileText} checked`));
+  return {
+    totalErrors,
+    totalWarnings,
+    schemaErrors: schemaErrors.length,
+    referenceErrors: referenceErrors.length,
+    parseErrors: parseErrors.length,
+    filesChecked: allFiles.size,
+    filesWithErrors
+  };
+};
+var groupParseErrorsByFile = (errors) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    const file = error.file.relativePath;
+    if (!grouped.has(file)) {
+      grouped.set(file, []);
+    }
+    grouped.get(file).push(error);
+  }
+  return grouped;
+};
+
+// src/config/index.ts
+var import_fs = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var DEFAULT_IGNORE_PATTERNS = ["dependencies/**"];
+var DEFAULT_RULES = {
+  "schema/required-fields": "error",
+  "schema/valid-semver": "error",
+  "schema/valid-email": "error",
+  "refs/owner-exists": "error",
+  "refs/valid-version-range": "error",
+  "refs/resource-exists": "error",
+  "refs/channel-exists": "error",
+  "refs/container-exists": "error",
+  "refs/orphan-messages": "warn",
+  "best-practices/summary-required": "error",
+  "best-practices/owner-required": "error",
+  "best-practices/description-required": "warn",
+  "best-practices/schema-required": "warn",
+  "naming/service-id-format": "error",
+  "naming/event-id-format": "error",
+  "versions/consistent-format": "error",
+  "versions/no-deprecated": "error",
+  "versions/no-deprecated-references": "warn",
+  "structure/duplicate-resource-ids": "error"
+};
+var PLURAL_TO_SINGULAR = {
+  events: "event",
+  commands: "command",
+  queries: "query",
+  services: "service",
+  domains: "domain",
+  entities: "entity",
+  channels: "channel",
+  flows: "flow",
+  users: "user",
+  teams: "team"
+};
+var loadEventCatalogConfig = (rootDir) => {
+  const configPath = import_path2.default.join(rootDir, "eventcatalog.config.js");
+  if (!import_fs.default.existsSync(configPath)) {
+    return {};
+  }
+  try {
+    delete require.cache[require.resolve(configPath)];
+    const config = require(configPath);
+    if (!config.dependencies || typeof config.dependencies !== "object") {
+      return {};
+    }
+    const dependencies = {};
+    for (const [pluralKey, entries] of Object.entries(config.dependencies)) {
+      const singularType = PLURAL_TO_SINGULAR[pluralKey];
+      if (!singularType || !Array.isArray(entries)) continue;
+      dependencies[singularType] = entries.filter((entry) => entry && typeof entry.id === "string").map((entry) => ({ id: entry.id, version: entry.version }));
+    }
+    return dependencies;
+  } catch (error) {
+    console.warn(`Warning: Could not load eventcatalog.config.js: ${error instanceof Error ? error.message : String(error)}`);
+    return {};
+  }
+};
+var loadConfig = (rootDir) => {
+  const configPath = import_path2.default.join(rootDir, ".eventcatalogrc.js");
+  if (!import_fs.default.existsSync(configPath)) {
+    return {
+      rules: DEFAULT_RULES,
+      ignorePatterns: DEFAULT_IGNORE_PATTERNS,
+      overrides: []
+    };
+  }
+  try {
+    delete require.cache[require.resolve(configPath)];
+    const config = require(configPath);
+    const mergedConfig = {
+      rules: { ...DEFAULT_RULES, ...config.rules },
+      ignorePatterns: [...DEFAULT_IGNORE_PATTERNS, ...config.ignorePatterns || []],
+      overrides: config.overrides || []
+    };
+    return mergedConfig;
+  } catch (error) {
+    console.warn(`Warning: Could not load .eventcatalogrc.js: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      rules: DEFAULT_RULES,
+      ignorePatterns: DEFAULT_IGNORE_PATTERNS,
+      overrides: []
+    };
+  }
+};
+var parseRuleConfig = (rule) => {
+  if (Array.isArray(rule)) {
+    return {
+      severity: rule[0],
+      options: rule[1]
+    };
+  }
+  return {
+    severity: rule,
+    options: {}
+  };
+};
+var shouldIgnoreFile = (filePath, ignorePatterns) => {
+  if (!ignorePatterns || ignorePatterns.length === 0) {
+    return false;
+  }
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  for (const pattern of ignorePatterns) {
+    const regex = new RegExp(pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"));
+    if (regex.test(normalizedPath)) {
+      return true;
+    }
+  }
+  return false;
+};
+var getEffectiveRules = (filePath, config) => {
+  let effectiveRules = { ...config.rules };
+  if (config.overrides) {
+    for (const override of config.overrides) {
+      const matchesFile = override.files.some((pattern) => {
+        const regex = new RegExp(pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"));
+        return regex.test(filePath);
+      });
+      if (matchesFile) {
+        effectiveRules = { ...effectiveRules, ...override.rules };
+      }
+    }
+  }
+  const parsedRules = {};
+  for (const [ruleName, ruleValue] of Object.entries(effectiveRules)) {
+    parsedRules[ruleName] = parseRuleConfig(ruleValue);
+  }
+  return parsedRules;
+};
+var applyRuleSeverity = (errors, rules) => {
+  const result = [];
+  for (const error of errors) {
+    const ruleName = mapErrorToRuleName(error);
+    const rule = rules[ruleName];
+    if (!rule || rule.severity === "off") {
+      continue;
+    }
+    result.push({
+      ...error,
+      severity: rule.severity === "warn" ? "warning" : "error"
+    });
+  }
+  return result;
+};
+var mapErrorToRuleName = (error) => {
+  if (error.rule) {
+    return error.rule;
+  }
+  if (error.type === "schema") {
+    if (error.field === "summary") {
+      return "best-practices/summary-required";
+    }
+    if (error.field === "owners") {
+      return "best-practices/owner-required";
+    }
+    if (error.message.includes("email") || error.message.includes("Invalid email")) {
+      return "schema/valid-email";
+    }
+    if (error.message.includes("version") || error.message.includes("semantic")) {
+      return "schema/valid-semver";
+    }
+    if (error.message.includes("Required") || error.message.includes("Expected")) {
+      return "schema/required-fields";
+    }
+    return "schema/required-fields";
+  }
+  if (error.type === "reference") {
+    if (error.message.includes("user") || error.message.includes("team")) {
+      return "refs/owner-exists";
+    }
+    if (error.message.includes("version")) {
+      return "refs/valid-version-range";
+    }
+    return "refs/resource-exists";
+  }
+  return "schema/required-fields";
+};
+
+// src/cli/index.ts
+var program = new import_commander.Command();
+program.name("eventcatalog-linter").description("Lint your EventCatalog for frontmatter and reference validation").version("0.1.0").argument("[directory]", "EventCatalog directory to lint", ".").option("-v, --verbose", "Show verbose output", false).option("--fail-on-warning", "Exit with non-zero code on warnings", false).action(async (directory, options) => {
+  const rootDir = import_path3.default.resolve(directory);
+  const spinner = (0, import_ora.default)("Loading configuration...").start();
+  try {
+    const config = loadConfig(rootDir);
+    const dependencies = loadEventCatalogConfig(rootDir);
+    spinner.text = "Scanning EventCatalog files...";
+    const allFiles = await scanCatalogFiles(rootDir);
+    const files = allFiles.filter((file) => !shouldIgnoreFile(file.relativePath, config.ignorePatterns || []));
+    const ignoredCount = allFiles.length - files.length;
+    if (ignoredCount > 0) {
+      spinner.text = `Found ${files.length} catalog files (${ignoredCount} ignored)`;
+    } else {
+      spinner.text = `Found ${files.length} catalog files`;
+    }
+    if (files.length === 0) {
+      spinner.warn("No EventCatalog files found");
+      process.exit(0);
+    }
+    spinner.text = "Parsing frontmatter...";
+    const { parsed, errors: parseErrors } = await parseAllFiles(files);
+    spinner.text = "Validating catalog...";
+    const rawValidationErrors = validateCatalog(parsed, dependencies);
+    const validationErrors = parsed.flatMap((parsedFile) => {
+      const fileErrors = rawValidationErrors.filter((error) => error.file === parsedFile.file.relativePath);
+      const effectiveRules = getEffectiveRules(parsedFile.file.relativePath, config);
+      return applyRuleSeverity(fileErrors, effectiveRules);
+    });
+    spinner.stop();
+    const summary = reportErrors(validationErrors, parseErrors, options.verbose);
+    if (summary.totalErrors === 0) {
+      console.log(import_chalk2.default.dim(`
+  ${files.length} files checked`));
+    }
+    if (summary.totalErrors > 0 || options.failOnWarning && summary.totalWarnings > 0) {
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail("An error occurred");
+    console.error(import_chalk2.default.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map