@pattern-stack/codegen 0.2.0

package/dist/src/index.js

@@ -0,0 +1,2198 @@
+// src/parser/load-entities.ts
+import { readdirSync } from "fs";
+import { join, resolve } from "path";
+
+// src/utils/yaml-loader.ts
+import { readFileSync, existsSync } from "fs";
+import { parse as parseYaml } from "yaml";
+
+// src/schema/entity-definition.schema.ts
+import { z } from "zod";
+var FieldTypeSchema = z.enum([
+  "string",
+  "integer",
+  "decimal",
+  "boolean",
+  "uuid",
+  "date",
+  "datetime",
+  "json",
+  "entity_ref",
+  // Polymorphic reference: generates {field}EntityType + {field}EntityId columns
+  "string_array",
+  // Array of strings: generates text[] column
+  "enum"
+  // Enum type with choices or choices_from
+]);
+var UiTypeSchema = z.enum([
+  "text",
+  "textarea",
+  "number",
+  "money",
+  "percentage",
+  "email",
+  "url",
+  "date",
+  "datetime",
+  "boolean",
+  "enum",
+  "reference",
+  "json",
+  "badge",
+  "password"
+]);
+var UiImportanceSchema = z.enum(["primary", "secondary", "tertiary"]);
+var AnalyticsAggregationSchema = z.enum([
+  "sum",
+  "min",
+  "max",
+  "count",
+  "count_distinct",
+  "average",
+  "median",
+  "percentile",
+  "sum_boolean"
+]);
+var AnalyticsDimensionTypeSchema = z.enum(["categorical", "time"]);
+var AnalyticsEntityTypeSchema = z.enum(["primary", "unique", "foreign", "natural"]);
+var AnalyticsTimeGranularitySchema = z.enum(["day", "week", "month", "quarter", "year"]);
+var AnalyticsVisibilitySchema = z.enum(["internal", "agent", "public"]);
+var NonAdditiveDimensionSchema = z.union([
+  z.string(),
+  z.object({
+    name: z.string(),
+    window_choice: z.string().optional(),
+    window_groupings: z.array(z.string()).optional()
+  })
+]);
+var SemanticMetadataSchema = z.object({
+  measure: z.boolean().optional(),
+  analytics_aggregation: AnalyticsAggregationSchema.optional(),
+  agg_time_dimension: z.string().optional(),
+  non_additive_dimension: NonAdditiveDimensionSchema.optional(),
+  dimension: z.boolean().optional(),
+  dimension_type: AnalyticsDimensionTypeSchema.optional(),
+  time_granularity: AnalyticsTimeGranularitySchema.optional(),
+  is_partition: z.boolean().optional(),
+  entity: z.boolean().optional(),
+  entity_type: AnalyticsEntityTypeSchema.optional(),
+  entity_role: z.string().optional(),
+  analytics_visibility: AnalyticsVisibilitySchema.optional(),
+  semantic_expr: z.string().optional(),
+  semantic_label: z.string().optional()
+});
+var UiMetadataSchema = z.object({
+  ui_label: z.string().optional(),
+  ui_type: UiTypeSchema.optional(),
+  ui_importance: UiImportanceSchema.optional(),
+  ui_group: z.string().optional(),
+  ui_sortable: z.boolean().optional(),
+  ui_filterable: z.boolean().optional(),
+  ui_visible: z.boolean().optional(),
+  ui_placeholder: z.string().optional(),
+  ui_help: z.string().optional(),
+  ui_format: z.record(z.unknown()).optional()
+});
+var BaseFieldSchema = z.object({
+  type: FieldTypeSchema,
+  required: z.boolean().optional().default(false),
+  nullable: z.boolean().optional().default(false),
+  // String constraints
+  max_length: z.number().int().positive().optional(),
+  min_length: z.number().int().nonnegative().optional(),
+  // Numeric constraints
+  min: z.number().optional(),
+  max: z.number().optional(),
+  // Enum/choices (inline definition)
+  choices: z.array(z.string()).optional(),
+  // Enum/choices from external file (e.g., "relationship_types.yaml")
+  // Mutually exclusive with choices - parser loads file and extracts keys
+  choices_from: z.string().optional(),
+  // Entity reference: allowed entity types for polymorphic refs
+  // Required when type is 'entity_ref'
+  allowed_types: z.array(z.string()).optional(),
+  // Default value
+  default: z.unknown().optional(),
+  // Indexing
+  index: z.boolean().optional(),
+  unique: z.boolean().optional(),
+  // Foreign key reference (e.g., "accounts.id")
+  foreign_key: z.string().optional()
+});
+var FieldDefinitionSchema = BaseFieldSchema.merge(UiMetadataSchema).merge(SemanticMetadataSchema).refine((data) => !(data.required === true && data.nullable === true), {
+  message: "'required: true' and 'nullable: true' cannot both be set. A required field cannot be null.",
+  path: ["required"]
+}).refine(
+  (data) => {
+    if (data.min_length !== void 0 && data.type !== "string") {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'min_length' can only be used with type 'string'",
+    path: ["min_length"]
+  }
+).refine(
+  (data) => {
+    if (data.max_length !== void 0 && data.type !== "string") {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'max_length' can only be used with type 'string'",
+    path: ["max_length"]
+  }
+).refine(
+  (data) => {
+    if (data.min !== void 0 && !["integer", "decimal"].includes(data.type)) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'min' can only be used with numeric types",
+    path: ["min"]
+  }
+).refine(
+  (data) => {
+    if (data.max !== void 0 && !["integer", "decimal"].includes(data.type)) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'max' can only be used with numeric types",
+    path: ["max"]
+  }
+).refine(
+  (data) => {
+    if (data.type === "entity_ref" && !data.allowed_types?.length) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'entity_ref' type requires 'allowed_types' to be specified",
+    path: ["allowed_types"]
+  }
+).refine(
+  (data) => {
+    if (data.allowed_types !== void 0 && data.type !== "entity_ref") {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'allowed_types' can only be used with type 'entity_ref'",
+    path: ["allowed_types"]
+  }
+).refine(
+  (data) => {
+    if (data.choices !== void 0 && data.choices_from !== void 0) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'choices' and 'choices_from' cannot both be specified",
+    path: ["choices_from"]
+  }
+).refine(
+  (data) => {
+    if (data.type === "enum" && !data.choices?.length && !data.choices_from) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'enum' type requires either 'choices' or 'choices_from'",
+    path: ["choices"]
+  }
+).refine(
+  (data) => {
+    if (data.measure === true && !data.analytics_aggregation) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "When 'measure' is true, 'analytics_aggregation' must be specified",
+    path: ["analytics_aggregation"]
+  }
+);
+var RelationshipTypeSchema = z.enum(["belongs_to", "has_many", "has_one"]);
+var RelationshipSchema = z.object({
+  type: RelationshipTypeSchema,
+  target: z.string(),
+  // Target entity name (e.g., "account")
+  foreign_key: z.string(),
+  // FK field name (e.g., "account_id")
+  through: z.string().optional(),
+  // For transitive: "owned_opportunities.updates"
+  inverse: z.string().optional()
+  // Name of inverse relationship on target entity
+}).strict();
+var BehaviorConfigSchema = z.union([
+  z.string(),
+  z.object({
+    name: z.string(),
+    options: z.record(z.unknown()).optional()
+  })
+]);
+var BehaviorStrategySchema = z.enum(["base_class", "inline"]);
+var FolderStructureSchema = z.enum(["nested", "flat"]).default("nested");
+var FileGroupingSchema = z.enum(["separate", "grouped"]).default("separate");
+var ExposeLayerSchema = z.enum(["repository", "rest", "trpc", "electric"]);
+var EntityConfigSchema = z.object({
+  name: z.string().regex(
+    /^[a-z][a-z0-9_]*$/,
+    "Entity name must be lowercase with underscores (e.g., 'opportunity')"
+  ),
+  plural: z.string().regex(/^[a-z][a-z0-9_]*$/, "Plural must be lowercase"),
+  table: z.string().regex(/^[a-z][a-z0-9_]*$/, "Table must be lowercase"),
+  // Layout options (orthogonal concerns)
+  // folder_structure: controls directory nesting
+  // file_grouping: controls file organization
+  folder_structure: FolderStructureSchema.optional(),
+  file_grouping: FileGroupingSchema.optional(),
+  // Per-entity behavior strategy override (overrides codegen.config.yaml)
+  behavior_strategy: BehaviorStrategySchema.optional(),
+  // Which layers to generate (default: all)
+  expose: z.array(ExposeLayerSchema).optional().default(["repository", "rest", "trpc"]),
+  // v2: Entity family classification (ADR-005)
+  // Determines which base class hierarchy the entity inherits from
+  family: z.enum(["base", "synced", "activity", "knowledge", "metadata"]).optional()
+}).strict();
+var QueryDeclarationSchema = z.object({
+  by: z.array(z.string()).min(1),
+  unique: z.boolean().optional(),
+  select: z.array(z.string()).optional(),
+  order: z.string().optional(),
+  limit: z.boolean().optional(),
+  via: z.string().optional()
+});
+var SyncDirectionSchema = z.enum([
+  "inbound",
+  "outbound",
+  "bidirectional"
+]);
+var ProviderSyncSchema = z.object({
+  remote_entity: z.string(),
+  direction: SyncDirectionSchema,
+  cdc: z.boolean().optional().default(false),
+  field_mapping: z.record(z.string(), z.string()).optional(),
+  read_only_fields: z.array(z.string()).optional()
+});
+var SyncConfigSchema = z.object({
+  electric: z.boolean().optional().default(false),
+  providers: z.record(z.string(), ProviderSyncSchema).optional()
+});
+var EventDeclarationSchema = z.object({
+  name: z.string().regex(/^[a-z][a-z0-9_]*$/, "Event name must be snake_case"),
+  queue: z.string(),
+  body: z.record(z.string(), z.string()),
+  generate_handler: z.boolean().optional().default(false)
+});
+var SimpleMetricSchema = z.object({
+  type: z.literal("simple"),
+  measure: z.string(),
+  agg: AnalyticsAggregationSchema.optional(),
+  filter: z.string().optional(),
+  description: z.string().optional(),
+  label: z.string().optional()
+});
+var DerivedMetricSchema = z.object({
+  type: z.literal("derived"),
+  expr: z.string(),
+  metrics: z.array(z.string()),
+  description: z.string().optional(),
+  label: z.string().optional()
+});
+var RatioMetricSchema = z.object({
+  type: z.literal("ratio"),
+  numerator: z.union([z.string(), SimpleMetricSchema]),
+  denominator: z.union([z.string(), SimpleMetricSchema]),
+  filter: z.string().optional(),
+  description: z.string().optional(),
+  label: z.string().optional()
+});
+var CumulativeMetricSchema = z.object({
+  type: z.literal("cumulative"),
+  measure: z.string(),
+  window: z.string().optional(),
+  grain_to_date: AnalyticsTimeGranularitySchema.optional(),
+  description: z.string().optional(),
+  label: z.string().optional()
+});
+var MetricDefinitionSchema = z.discriminatedUnion("type", [
+  SimpleMetricSchema,
+  DerivedMetricSchema,
+  RatioMetricSchema,
+  CumulativeMetricSchema
+]);
+var AnalyticsBlockSchema = z.object({
+  measure_packs: z.array(z.string()).optional(),
+  cube_name: z.string().optional(),
+  metrics: z.record(z.string(), MetricDefinitionSchema).optional()
+});
+var EntityDefinitionSchema = z.object({
+  entity: EntityConfigSchema,
+  fields: z.record(z.string(), FieldDefinitionSchema),
+  relationships: z.record(z.string(), RelationshipSchema).optional(),
+  // Behaviors add cross-cutting concerns (timestamps, soft_delete, user_tracking, etc.)
+  behaviors: z.array(BehaviorConfigSchema).optional().default([]),
+  // v2: Declarative query generation (ADR-005)
+  // Generates repository + service + use case methods from declarations
+  queries: z.array(QueryDeclarationSchema).optional(),
+  // v2: Integration sync configuration (CODEGEN-EVOLUTION-PLAN Phase 2)
+  // Electric SQL + provider sync (Salesforce, HubSpot, etc.)
+  sync: SyncConfigSchema.optional(),
+  // v2: Domain event declarations (CODEGEN-EVOLUTION-PLAN Phase 2)
+  // Generates typed event classes, handlers, and queue registration
+  events: z.array(EventDeclarationSchema).optional(),
+  // v2: Analytics / semantic layer configuration
+  // Cube.js measure packs, custom cube name, and metric definitions
+  analytics: AnalyticsBlockSchema.optional()
+}).strict();
+
+// src/schema/relationship-definition.schema.ts
+import { z as z2 } from "zod";
+var TypeDirectionSchema = z2.object({
+  /** Name of the inverse type when viewed from the other direction */
+  inverse: z2.string().optional(),
+  /** Both directions are equivalent — queries should check both FK columns */
+  bidirectional: z2.boolean().optional(),
+  /** Explicitly directed, no named inverse (default behavior) */
+  directed: z2.boolean().optional()
+}).refine(
+  (data) => {
+    const set = [data.inverse, data.bidirectional, data.directed].filter(
+      (v) => v !== void 0
+    );
+    return set.length === 1;
+  },
+  {
+    message: "Exactly one of inverse, bidirectional, or directed must be specified"
+  }
+);
+var RelationshipTypesSchema = z2.union([
+  // Simple list: all types are directed from→to
+  z2.array(z2.string().regex(/^[a-z][a-z0-9_]*$/, "Type must be snake_case")),
+  // Object map: each type has direction metadata
+  z2.record(
+    z2.string().regex(/^[a-z][a-z0-9_]*$/, "Type key must be snake_case"),
+    TypeDirectionSchema
+  )
+]);
+var OnDeleteActionSchema = z2.enum(["restrict", "cascade", "set_null", "no_action"]).default("restrict");
+var RelationshipConfigSchema = z2.object({
+  /** Relationship name (snake_case). Used for class/file naming. */
+  name: z2.string().regex(
+    /^[a-z][a-z0-9_]*$/,
+    "Relationship name must be snake_case"
+  ),
+  /** Database table name. Defaults to {name}s if not specified. */
+  table: z2.string().regex(/^[a-z][a-z0-9_]*$/, "Table must be snake_case").optional(),
+  /** The "from" entity — generates {entity}_id FK column (subject). */
+  from: z2.string().regex(/^[a-z][a-z0-9_]*$/, "Entity name must be snake_case"),
+  /** The "to" entity — generates {entity}_id FK column (object). */
+  to: z2.string().regex(/^[a-z][a-z0-9_]*$/, "Entity name must be snake_case"),
+  /**
+   * Relationship subtypes. Optional — omit for untyped junctions.
+   * When present, generates a `type` enum column on the junction table.
+   *
+   * Simple list: all types are directed (from→to). Use for cross-type
+   * relationships where entity asymmetry makes direction obvious.
+   *
+   * Object map: each type declares its own direction metadata.
+   * Required for self-referential relationships (from === to).
+   */
+  types: RelationshipTypesSchema.optional(),
+  /**
+   * Generate temporal validity fields: valid_from (date), valid_to (date?),
+   * is_current (boolean, denormalized for query performance).
+   * Default: true
+   */
+  temporal: z2.boolean().default(true),
+  /**
+   * Generate source tracking fields: source (enum), confidence (decimal 0-1).
+   * Default: true
+   */
+  sourced: z2.boolean().default(true),
+  /** on_delete action for the "from" endpoint FK. Default: restrict */
+  on_delete_from: OnDeleteActionSchema.optional(),
+  /** on_delete action for the "to" endpoint FK. Default: restrict */
+  on_delete_to: OnDeleteActionSchema.optional(),
+  /**
+   * Override the default unique constraint columns.
+   *
+   * Defaults:
+   * - Typed: [from_id, to_id, type]
+   * - Typed + temporal: [from_id, to_id, type, valid_from]
+   * - Untyped: [from_id, to_id]
+   *
+   * Use this when the default doesn't fit — e.g., allowing multiple
+   * relationships of the same type between the same entities at different times.
+   */
+  unique_on: z2.array(z2.string()).optional()
+}).strict();
+var RelationshipQuerySchema = z2.object({
+  by: z2.array(z2.string()).min(1),
+  unique: z2.boolean().optional(),
+  select: z2.array(z2.string()).optional(),
+  order: z2.string().optional(),
+  limit: z2.boolean().optional()
+});
+var RelationshipDefinitionSchema = z2.object({
+  /** Relationship configuration block */
+  relationship: RelationshipConfigSchema,
+  /**
+   * Additional fields beyond auto-generated ones.
+   * These describe the relationship, not either endpoint entity.
+   * Uses the same field definition schema as entity fields.
+   */
+  fields: z2.record(z2.string(), z2.any()).optional(),
+  /** Declarative queries — same syntax as entity queries. */
+  queries: z2.array(RelationshipQuerySchema).optional()
+}).strict().refine(
+  (data) => {
+    if (data.relationship.from === data.relationship.to && data.relationship.types) {
+      return !Array.isArray(data.relationship.types);
+    }
+    return true;
+  },
+  {
+    message: "Self-referential relationships must use the object map form for types (with inverse/bidirectional/directed metadata), not a simple list",
+    path: ["relationship", "types"]
+  }
+).refine(
+  (data) => {
+    if (!data.fields) return true;
+    const reserved = getReservedColumnNames(data.relationship);
+    const collisions = Object.keys(data.fields).filter(
+      (key) => reserved.has(key)
+    );
+    return collisions.length === 0;
+  },
+  {
+    message: "fields: contains keys that collide with auto-generated columns. Reserved names depend on config (type, valid_from, valid_to, is_current, source, confidence, id, created_at, updated_at, and FK columns).",
+    path: ["fields"]
+  }
+);
+function getReservedColumnNames(config) {
+  const { fromColumn, toColumn } = deriveRelationshipFKColumns(config);
+  const reserved = /* @__PURE__ */ new Set([
+    "id",
+    "created_at",
+    "updated_at",
+    fromColumn,
+    toColumn
+  ]);
+  if (config.types) {
+    reserved.add("type");
+  }
+  if (config.temporal) {
+    reserved.add("valid_from");
+    reserved.add("valid_to");
+    reserved.add("is_current");
+  }
+  if (config.sourced) {
+    reserved.add("source");
+    reserved.add("confidence");
+  }
+  return reserved;
+}
+function deriveRelationshipFKColumns(config) {
+  if (config.from === config.to) {
+    return {
+      fromColumn: `from_${config.from}_id`,
+      toColumn: `to_${config.to}_id`
+    };
+  }
+  return {
+    fromColumn: `${config.from}_id`,
+    toColumn: `${config.to}_id`
+  };
+}
+function deriveTableName(config) {
+  return config.table ?? `${config.name}s`;
+}
+function deriveUniqueConstraint(config) {
+  if (config.unique_on) return config.unique_on;
+  const { fromColumn, toColumn } = deriveRelationshipFKColumns(config);
+  const columns = [fromColumn, toColumn];
+  if (config.types) {
+    columns.push("type");
+  }
+  if (config.temporal && config.types) {
+    columns.push("valid_from");
+  }
+  return columns;
+}
+
+// src/utils/yaml-loader.ts
+function loadEntityFromYaml(filePath) {
+  if (!existsSync(filePath)) {
+    return {
+      success: false,
+      error: `File not found: ${filePath}`,
+      filePath
+    };
+  }
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read file: ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Invalid YAML syntax in ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  const result = EntityDefinitionSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      success: false,
+      error: `Validation failed for ${filePath}`,
+      details: formatZodErrors(result.error),
+      filePath
+    };
+  }
+  return {
+    success: true,
+    definition: result.data,
+    filePath
+  };
+}
+function formatZodErrors(error) {
+  return error.errors.map((err) => {
+    const path = err.path.join(".");
+    const location = path ? `at '${path}'` : "at root";
+    return `${err.message} ${location}`;
+  });
+}
+function loadRelationshipFromYaml(filePath) {
+  if (!existsSync(filePath)) {
+    return {
+      success: false,
+      error: `File not found: ${filePath}`,
+      filePath
+    };
+  }
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read file: ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Invalid YAML syntax in ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  const result = RelationshipDefinitionSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      success: false,
+      error: `Validation failed for ${filePath}`,
+      details: formatZodErrors(result.error),
+      filePath
+    };
+  }
+  return {
+    success: true,
+    definition: result.data,
+    filePath
+  };
+}
+
+// src/parser/load-entities.ts
+function transformToEntity(result) {
+  const { definition, filePath } = result;
+  const queries = definition.queries?.map((q) => ({
+    by: q.by,
+    unique: q.unique,
+    select: q.select,
+    order: q.order,
+    limit: q.limit,
+    via: q.via
+  }));
+  const entity = {
+    name: definition.entity.name,
+    plural: definition.entity.plural,
+    table: definition.entity.table,
+    family: definition.entity.family,
+    folderStructure: definition.entity.folder_structure ?? "nested",
+    fields: /* @__PURE__ */ new Map(),
+    relationships: /* @__PURE__ */ new Map(),
+    behaviors: definition.behaviors.map((b) => typeof b === "string" ? b : b.name),
+    queries,
+    sourcePath: filePath
+  };
+  for (const [name, fieldDef] of Object.entries(definition.fields)) {
+    const field = {
+      name,
+      type: fieldDef.type,
+      required: fieldDef.required ?? false,
+      nullable: fieldDef.nullable ?? false,
+      unique: fieldDef.unique ?? false,
+      index: fieldDef.index ?? false,
+      foreignKey: fieldDef.foreign_key ? parseForeignKey(fieldDef.foreign_key) : void 0,
+      choices: fieldDef.choices,
+      constraints: {
+        minLength: fieldDef.min_length,
+        maxLength: fieldDef.max_length,
+        min: fieldDef.min,
+        max: fieldDef.max
+      },
+      ui: {
+        label: fieldDef.ui_label,
+        type: fieldDef.ui_type,
+        importance: fieldDef.ui_importance,
+        group: fieldDef.ui_group,
+        sortable: fieldDef.ui_sortable,
+        filterable: fieldDef.ui_filterable,
+        visible: fieldDef.ui_visible
+      }
+    };
+    entity.fields.set(name, field);
+  }
+  if (definition.relationships) {
+    for (const [name, relDef] of Object.entries(definition.relationships)) {
+      const relationship = {
+        name,
+        type: relDef.type,
+        target: relDef.target,
+        foreignKey: relDef.foreign_key,
+        inverse: relDef.inverse,
+        through: relDef.through,
+        resolved: false
+      };
+      entity.relationships.set(name, relationship);
+    }
+  }
+  if (definition.sync) {
+    const syncDef = definition.sync;
+    const parsedSync = {
+      electric: syncDef.electric ?? false
+    };
+    if (syncDef.providers) {
+      parsedSync.providers = {};
+      for (const [providerName, providerDef] of Object.entries(syncDef.providers)) {
+        const parsedProvider = {
+          remoteEntity: providerDef.remote_entity,
+          direction: providerDef.direction,
+          cdc: providerDef.cdc ?? false
+        };
+        if (providerDef.field_mapping) {
+          parsedProvider.fieldMapping = providerDef.field_mapping;
+        }
+        if (providerDef.read_only_fields) {
+          parsedProvider.readOnlyFields = providerDef.read_only_fields;
+        }
+        parsedSync.providers[providerName] = parsedProvider;
+      }
+    }
+    entity.sync = parsedSync;
+  }
+  if (definition.events) {
+    entity.events = definition.events.map((ev) => ({
+      name: ev.name,
+      queue: ev.queue,
+      body: ev.body,
+      generateHandler: ev.generate_handler
+    }));
+  }
+  return entity;
+}
+function parseForeignKey(fk) {
+  const [table, column] = fk.split(".");
+  return { table, column: column ?? "id" };
+}
+function loadErrorToIssue(error) {
+  const issues = [];
+  issues.push({
+    severity: "error",
+    type: "parse_error",
+    message: error.error,
+    path: error.filePath
+  });
+  if (error.details) {
+    for (const detail of error.details) {
+      issues.push({
+        severity: "error",
+        type: "schema_error",
+        message: detail,
+        path: error.filePath
+      });
+    }
+  }
+  return issues;
+}
+function loadEntities(entitiesDir) {
+  const entities = [];
+  const issues = [];
+  const resolvedDir = resolve(entitiesDir);
+  let files;
+  try {
+    files = readdirSync(resolvedDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).map((f) => join(resolvedDir, f));
+  } catch (err) {
+    issues.push({
+      severity: "error",
+      type: "parse_error",
+      message: `Failed to read directory: ${resolvedDir}`,
+      path: resolvedDir
+    });
+    return { entities, issues };
+  }
+  if (files.length === 0) {
+    issues.push({
+      severity: "warning",
+      type: "no_files",
+      message: `No YAML files found in directory: ${resolvedDir}`,
+      path: resolvedDir
+    });
+    return { entities, issues };
+  }
+  for (const filePath of files) {
+    const result = loadEntityFromYaml(filePath);
+    if (result.success) {
+      entities.push(transformToEntity(result));
+    } else {
+      issues.push(...loadErrorToIssue(result));
+    }
+  }
+  return { entities, issues };
+}
+function resolveReferences(entities) {
+  const issues = [];
+  const entityMap = /* @__PURE__ */ new Map();
+  for (const entity of entities) {
+    if (entityMap.has(entity.name)) {
+      issues.push({
+        severity: "error",
+        type: "duplicate_entity",
+        entity: entity.name,
+        message: `Duplicate entity name: ${entity.name}`,
+        path: entity.sourcePath
+      });
+    }
+    entityMap.set(entity.name, entity);
+  }
+  for (const entity of entities) {
+    for (const [relName, rel] of entity.relationships) {
+      const targetEntity = entityMap.get(rel.target);
+      if (targetEntity) {
+        rel.resolved = true;
+      } else {
+        issues.push({
+          severity: "error",
+          type: "missing_target",
+          entity: entity.name,
+          field: relName,
+          message: `Relationship '${relName}' references unknown entity '${rel.target}'`,
+          path: entity.sourcePath,
+          suggestion: `Define entity '${rel.target}' or fix the target name`
+        });
+      }
+    }
+    for (const [fieldName, field] of entity.fields) {
+      if (field.foreignKey) {
+        const targetTable = field.foreignKey.table;
+        const targetEntity = Array.from(entityMap.values()).find(
+          (e) => e.table === targetTable
+        );
+        if (!targetEntity) {
+          issues.push({
+            severity: "warning",
+            type: "missing_fk_target",
+            entity: entity.name,
+            field: fieldName,
+            message: `Foreign key references unknown table '${targetTable}'`,
+            path: entity.sourcePath,
+            suggestion: `Define entity with table '${targetTable}' or fix the foreign_key reference`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function transformToRelationshipDefinition(result) {
+  const { definition, filePath } = result;
+  const config = definition.relationship;
+  const { fromColumn, toColumn } = deriveRelationshipFKColumns(config);
+  const table = deriveTableName(config);
+  const uniqueOn = deriveUniqueConstraint(config);
+  const types = resolveTypeDirections(config.types);
+  const fields = /* @__PURE__ */ new Map();
+  if (definition.fields) {
+    for (const [name, fieldDef] of Object.entries(definition.fields)) {
+      const field = {
+        name,
+        type: fieldDef.type,
+        required: fieldDef.required ?? false,
+        nullable: fieldDef.nullable ?? false,
+        unique: fieldDef.unique ?? false,
+        index: fieldDef.index ?? false,
+        foreignKey: fieldDef.foreign_key ? parseForeignKey(fieldDef.foreign_key) : void 0,
+        choices: fieldDef.choices,
+        constraints: {
+          minLength: fieldDef.min_length,
+          maxLength: fieldDef.max_length,
+          min: fieldDef.min,
+          max: fieldDef.max
+        },
+        ui: {
+          label: fieldDef.ui_label,
+          type: fieldDef.ui_type,
+          importance: fieldDef.ui_importance,
+          group: fieldDef.ui_group,
+          sortable: fieldDef.ui_sortable,
+          filterable: fieldDef.ui_filterable,
+          visible: fieldDef.ui_visible
+        }
+      };
+      fields.set(name, field);
+    }
+  }
+  const queries = definition.queries?.map((q) => ({
+    by: q.by,
+    unique: q.unique,
+    select: q.select,
+    order: q.order,
+    limit: q.limit
+  }));
+  return {
+    name: config.name,
+    table,
+    from: config.from,
+    to: config.to,
+    selfReferential: config.from === config.to,
+    fromColumn,
+    toColumn,
+    types,
+    hasTypes: types.length > 0,
+    temporal: config.temporal,
+    sourced: config.sourced,
+    onDeleteFrom: config.on_delete_from ?? "restrict",
+    onDeleteTo: config.on_delete_to ?? "restrict",
+    uniqueOn,
+    fields,
+    queries,
+    sourcePath: filePath
+  };
+}
+function resolveTypeDirections(types) {
+  if (!types) return [];
+  if (Array.isArray(types)) {
+    return types.map((name) => ({
+      name,
+      bidirectional: false,
+      directed: true
+    }));
+  }
+  return Object.entries(types).map(([name, dir]) => {
+    const direction = dir;
+    return {
+      name,
+      inverse: direction.inverse,
+      bidirectional: direction.bidirectional ?? false,
+      directed: direction.directed ?? (!direction.bidirectional && !direction.inverse)
+    };
+  });
+}
+function loadRelationships(relationshipsDir) {
+  const relationships = [];
+  const issues = [];
+  const resolvedDir = resolve(relationshipsDir);
+  let files;
+  try {
+    files = readdirSync(resolvedDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).map((f) => join(resolvedDir, f));
+  } catch {
+    return { relationships, issues };
+  }
+  if (files.length === 0) {
+    return { relationships, issues };
+  }
+  for (const filePath of files) {
+    const result = loadRelationshipFromYaml(filePath);
+    if (result.success) {
+      relationships.push(transformToRelationshipDefinition(result));
+    } else {
+      issues.push(...loadErrorToIssue(result));
+    }
+  }
+  return { relationships, issues };
+}
+function resolveRelationshipReferences(relationshipDefs, entities) {
+  const issues = [];
+  const entityNames = new Set(entities.map((e) => e.name));
+  for (const relDef of relationshipDefs) {
+    if (!entityNames.has(relDef.from)) {
+      issues.push({
+        severity: "warning",
+        type: "missing_relationship_endpoint",
+        entity: relDef.name,
+        message: `Relationship '${relDef.name}' references unknown 'from' entity '${relDef.from}'`,
+        path: relDef.sourcePath,
+        suggestion: `Define entity '${relDef.from}' or fix the 'from' value`
+      });
+    }
+    if (!entityNames.has(relDef.to)) {
+      issues.push({
+        severity: "warning",
+        type: "missing_relationship_endpoint",
+        entity: relDef.name,
+        message: `Relationship '${relDef.name}' references unknown 'to' entity '${relDef.to}'`,
+        path: relDef.sourcePath,
+        suggestion: `Define entity '${relDef.to}' or fix the 'to' value`
+      });
+    }
+    const dupes = relationshipDefs.filter((r) => r.name === relDef.name);
+    if (dupes.length > 1) {
+      issues.push({
+        severity: "error",
+        type: "duplicate_relationship",
+        entity: relDef.name,
+        message: `Duplicate relationship name: ${relDef.name}`,
+        path: relDef.sourcePath
+      });
+    }
+  }
+  return issues;
+}
+
+// src/analyzer/graph-builder.ts
+function inferCardinality(type) {
+  switch (type) {
+    case "belongs_to":
+      return "N:1";
+    case "has_many":
+      return "1:N";
+    case "has_one":
+      return "1:1";
+    default:
+      return "1:N";
+  }
+}
+function hasReverseEdge(edges, from, to) {
+  return edges.find((e) => e.from === to && e.to === from);
+}
+function buildDomainGraph(entities, relationshipDefinitions = []) {
+  const entityMap = /* @__PURE__ */ new Map();
+  const relDefMap = /* @__PURE__ */ new Map();
+  const edges = [];
+  for (const entity of entities) {
+    entityMap.set(entity.name, entity);
+  }
+  for (const relDef of relationshipDefinitions) {
+    relDefMap.set(relDef.name, relDef);
+  }
+  for (const entity of entities) {
+    for (const [relName, rel] of entity.relationships) {
+      if (!rel.resolved) continue;
+      const reverseEdge = hasReverseEdge(edges, entity.name, rel.target);
+      const edge = {
+        from: entity.name,
+        to: rel.target,
+        relationship: rel,
+        cardinality: inferCardinality(rel.type),
+        bidirectional: reverseEdge !== void 0
+      };
+      if (reverseEdge) {
+        reverseEdge.bidirectional = true;
+      }
+      edges.push(edge);
+    }
+  }
+  for (const relDef of relationshipDefinitions) {
+    const fromExists = entityMap.has(relDef.from);
+    const toExists = entityMap.has(relDef.to);
+    if (fromExists && toExists) {
+      const edge = {
+        from: relDef.from,
+        to: relDef.to,
+        relationship: {
+          name: relDef.name,
+          type: "has_many",
+          target: relDef.to,
+          foreignKey: relDef.fromColumn,
+          resolved: true
+        },
+        cardinality: "N:M",
+        bidirectional: relDef.types.some((t) => t.bidirectional)
+      };
+      edges.push(edge);
+    }
+  }
+  return { entities: entityMap, relationshipDefinitions: relDefMap, edges };
+}
+function getRelatedEntities(graph, entityName, depth = 1) {
+  const related = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [
+    { name: entityName, currentDepth: 0 }
+  ];
+  while (queue.length > 0) {
+    const item = queue.shift();
+    if (!item) continue;
+    const { name, currentDepth } = item;
+    if (visited.has(name) || currentDepth > depth) continue;
+    visited.add(name);
+    for (const edge of graph.edges) {
+      if (edge.from === name && !visited.has(edge.to)) {
+        related.add(edge.to);
+        queue.push({ name: edge.to, currentDepth: currentDepth + 1 });
+      }
+      if (edge.to === name && !visited.has(edge.from)) {
+        related.add(edge.from);
+        queue.push({ name: edge.from, currentDepth: currentDepth + 1 });
+      }
+    }
+  }
+  return related;
+}
+function findOrphanEntities(graph) {
+  const orphans = [];
+  for (const [name] of graph.entities) {
+    const hasRelationship = graph.edges.some((e) => e.from === name || e.to === name);
+    if (!hasRelationship) {
+      orphans.push(name);
+    }
+  }
+  return orphans;
+}
+function findCircularDependencies(graph) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function dfs(node, path) {
+    visited.add(node);
+    recursionStack.add(node);
+    const outgoingEdges = graph.edges.filter((e) => e.from === node);
+    for (const edge of outgoingEdges) {
+      if (!visited.has(edge.to)) {
+        dfs(edge.to, [...path, edge.to]);
+      } else if (recursionStack.has(edge.to)) {
+        const cycleStart = path.indexOf(edge.to);
+        if (cycleStart !== -1) {
+          cycles.push([...path.slice(cycleStart), edge.to]);
+        } else {
+          cycles.push([...path, edge.to]);
+        }
+      }
+    }
+    recursionStack.delete(node);
+  }
+  for (const [name] of graph.entities) {
+    if (!visited.has(name)) {
+      dfs(name, [name]);
+    }
+  }
+  const uniqueCycles = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const cycle of cycles) {
+    const minIndex = cycle.indexOf(
+      cycle.reduce((min, val) => val < min ? val : min, cycle[0])
+    );
+    const normalized = [...cycle.slice(minIndex), ...cycle.slice(0, minIndex)];
+    const key = normalized.join("->");
+    if (!seen.has(key)) {
+      seen.add(key);
+      uniqueCycles.push(cycle);
+    }
+  }
+  return uniqueCycles;
+}
+
+// src/behaviors/external-id-tracking.ts
+var externalIdTrackingBehavior = {
+  name: "external_id_tracking",
+  description: "Adds external_id, provider, and provider_metadata fields for external system sync tracking",
+  fields: [
+    {
+      name: "external_id",
+      camelName: "externalId",
+      type: "string",
+      tsType: "string | null",
+      drizzleType: "varchar",
+      drizzleImports: ["varchar", "index"],
+      zodType: "z.string().nullable()",
+      nullable: true,
+      ui: {
+        label: "External ID",
+        type: "text",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    },
+    {
+      name: "provider",
+      camelName: "provider",
+      type: "string",
+      tsType: "string | null",
+      drizzleType: "varchar",
+      drizzleImports: ["varchar"],
+      zodType: "z.string().nullable()",
+      nullable: true,
+      ui: {
+        label: "Provider",
+        type: "text",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    },
+    {
+      name: "provider_metadata",
+      camelName: "providerMetadata",
+      type: "json",
+      tsType: "unknown | null",
+      drizzleType: "jsonb",
+      drizzleImports: ["jsonb"],
+      zodType: "z.unknown().nullable()",
+      nullable: true,
+      ui: {
+        label: "Provider Metadata",
+        type: "json",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    }
+  ],
+  drizzleImports: ["varchar", "jsonb", "index"],
+  configKey: "externalIdTracking"
+};
+
+// src/behaviors/soft-delete.ts
+var softDeleteBehavior = {
+  name: "soft_delete",
+  description: "Adds deleted_at field for soft delete functionality",
+  fields: [
+    {
+      name: "deleted_at",
+      camelName: "deletedAt",
+      type: "datetime",
+      tsType: "Date | null",
+      drizzleType: "timestamp",
+      drizzleImports: ["timestamp"],
+      zodType: "z.coerce.date().nullable()",
+      nullable: true,
+      ui: {
+        label: "Deleted At",
+        type: "datetime",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    }
+  ],
+  drizzleImports: ["timestamp"],
+  methods: [
+    "softDelete",
+    "restore",
+    "findWithDeleted",
+    "findOnlyDeleted",
+    "baseQuery"
+    // Modified to filter deleted records
+  ],
+  configKey: "softDelete"
+};
+
+// src/behaviors/timestamps.ts
+var timestampsBehavior = {
+  name: "timestamps",
+  description: "Adds created_at and updated_at timestamp fields",
+  fields: [
+    {
+      name: "created_at",
+      camelName: "createdAt",
+      type: "datetime",
+      tsType: "Date",
+      drizzleType: "timestamp",
+      drizzleImports: ["timestamp"],
+      zodType: "z.coerce.date()",
+      nullable: false,
+      default: "now()",
+      ui: {
+        label: "Created At",
+        type: "datetime",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    },
+    {
+      name: "updated_at",
+      camelName: "updatedAt",
+      type: "datetime",
+      tsType: "Date",
+      drizzleType: "timestamp",
+      drizzleImports: ["timestamp"],
+      zodType: "z.coerce.date()",
+      nullable: false,
+      default: "now()",
+      ui: {
+        label: "Updated At",
+        type: "datetime",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    }
+  ],
+  drizzleImports: ["timestamp"],
+  methods: ["applyTimestampsOnCreate", "applyTimestampsOnUpdate"],
+  configKey: "timestamps"
+};
+
+// src/behaviors/user-tracking.ts
+var userTrackingBehavior = {
+  name: "user_tracking",
+  description: "Adds created_by and updated_by user reference fields",
+  fields: [
+    {
+      name: "created_by",
+      camelName: "createdBy",
+      type: "uuid",
+      tsType: "string | null",
+      drizzleType: "uuid",
+      drizzleImports: ["uuid"],
+      zodType: "z.string().uuid().nullable()",
+      nullable: true,
+      foreignKey: "users.id",
+      ui: {
+        label: "Created By",
+        type: "reference",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    },
+    {
+      name: "updated_by",
+      camelName: "updatedBy",
+      type: "uuid",
+      tsType: "string | null",
+      drizzleType: "uuid",
+      drizzleImports: ["uuid"],
+      zodType: "z.string().uuid().nullable()",
+      nullable: true,
+      foreignKey: "users.id",
+      ui: {
+        label: "Updated By",
+        type: "reference",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    }
+  ],
+  drizzleImports: ["uuid"],
+  methods: ["applyUserTrackingOnCreate", "applyUserTrackingOnUpdate"],
+  configKey: "userTracking"
+};
+
+// src/behaviors/index.ts
+var behaviorRegistry = /* @__PURE__ */ new Map([
+  ["timestamps", timestampsBehavior],
+  ["soft_delete", softDeleteBehavior],
+  ["user_tracking", userTrackingBehavior],
+  ["external_id_tracking", externalIdTrackingBehavior]
+]);
+function getBehavior(name) {
+  return behaviorRegistry.get(name);
+}
+function normalizeBehaviorConfig(config) {
+  if (typeof config === "string") {
+    return { name: config, options: {} };
+  }
+  return { name: config.name, options: config.options ?? {} };
+}
+function normalizeBehaviorConfigs(configs) {
+  return configs.map(normalizeBehaviorConfig);
+}
+function resolveBehaviorFields(configs) {
+  const normalized = normalizeBehaviorConfigs(configs);
+  const fields = [];
+  const addedFieldNames = /* @__PURE__ */ new Set();
+  for (const config of normalized) {
+    const behavior = getBehavior(config.name);
+    if (!behavior) continue;
+    for (const field of behavior.fields) {
+      if (!addedFieldNames.has(field.name)) {
+        fields.push(field);
+        addedFieldNames.add(field.name);
+      }
+    }
+  }
+  return fields;
+}
+
+// src/analyzer/consistency-checker.ts
+function checkConsistency(graph) {
+  const issues = [];
+  for (const [name, entity] of graph.entities) {
+    issues.push(...checkEntityConsistency(entity));
+    issues.push(...checkRelationshipConsistency(entity, graph));
+    issues.push(...checkNamingConventions(entity));
+    issues.push(...checkMissingIndexes(entity));
+    issues.push(...checkUiMetadata(entity));
+    if (entity.queries !== void 0) {
+      issues.push(...checkQueryFieldReferences(entity));
+    }
+    if (entity.sync !== void 0) {
+      issues.push(...checkSyncFieldMappingReferences(entity));
+      issues.push(...checkExternalIdTrackingCollision(entity));
+    }
+  }
+  issues.push(...checkOrphanEntities(graph));
+  issues.push(...checkCircularReferences(graph));
+  issues.push(...checkMissingInverses(graph));
+  return issues;
+}
+function checkEntityConsistency(entity) {
+  const issues = [];
+  if (!entity.fields.has("id")) {
+    issues.push({
+      severity: "info",
+      type: "missing_id",
+      entity: entity.name,
+      message: 'Entity missing standard "id" field',
+      suggestion: 'Add an "id" field with type "uuid"'
+    });
+  }
+  const hasCreatedAt = entity.fields.has("created_at");
+  const hasTimestampsBehavior = entity.behaviors.includes("timestamps");
+  if (!hasCreatedAt && !hasTimestampsBehavior) {
+    issues.push({
+      severity: "info",
+      type: "missing_timestamps",
+      entity: entity.name,
+      message: 'Entity missing "created_at" field and "timestamps" behavior',
+      suggestion: 'Add "timestamps" to behaviors or add created_at/updated_at fields'
+    });
+  }
+  return issues;
+}
+function checkRelationshipConsistency(entity, graph) {
+  const issues = [];
+  for (const [relName, rel] of entity.relationships) {
+    if (rel.type === "belongs_to") {
+      const fkField = entity.fields.get(rel.foreignKey);
+      if (!fkField) {
+        issues.push({
+          severity: "warning",
+          type: "missing_fk_field",
+          entity: entity.name,
+          field: relName,
+          message: `Relationship "${relName}" references foreign key "${rel.foreignKey}" but field doesn't exist`,
+          suggestion: `Add field "${rel.foreignKey}" with foreign_key reference`
+        });
+      }
+    }
+    if (rel.type === "has_many" || rel.type === "has_one") {
+      const targetEntity = graph.entities.get(rel.target);
+      if (targetEntity) {
+        const targetFkField = targetEntity.fields.get(rel.foreignKey);
+        if (!targetFkField) {
+          issues.push({
+            severity: "warning",
+            type: "missing_target_fk",
+            entity: entity.name,
+            field: relName,
+            message: `Relationship "${relName}" expects foreign key "${rel.foreignKey}" on "${rel.target}" but field doesn't exist`,
+            suggestion: `Add field "${rel.foreignKey}" to "${rel.target}" entity`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function checkNamingConventions(entity) {
+  const issues = [];
+  if (entity.name !== entity.name.toLowerCase()) {
+    issues.push({
+      severity: "warning",
+      type: "naming_convention",
+      entity: entity.name,
+      message: "Entity name should be lowercase",
+      suggestion: `Use "${entity.name.toLowerCase()}"`
+    });
+  }
+  for (const [fieldName] of entity.fields) {
+    if (fieldName !== fieldName.toLowerCase()) {
+      issues.push({
+        severity: "warning",
+        type: "naming_convention",
+        entity: entity.name,
+        field: fieldName,
+        message: "Field name should be snake_case",
+        suggestion: `Use "${toSnakeCase(fieldName)}"`
+      });
+    }
+  }
+  for (const [relName] of entity.relationships) {
+    if (relName !== relName.toLowerCase()) {
+      issues.push({
+        severity: "warning",
+        type: "naming_convention",
+        entity: entity.name,
+        field: relName,
+        message: "Relationship name should be snake_case",
+        suggestion: `Use "${toSnakeCase(relName)}"`
+      });
+    }
+  }
+  return issues;
+}
+function checkMissingIndexes(entity) {
+  const issues = [];
+  for (const [fieldName, field] of entity.fields) {
+    if (field.ui.filterable && !field.index && !field.unique) {
+      issues.push({
+        severity: "warning",
+        type: "missing_index",
+        entity: entity.name,
+        field: fieldName,
+        message: `Field "${fieldName}" is filterable but has no index`,
+        suggestion: 'Add "index: true" to improve query performance'
+      });
+    }
+    if (field.foreignKey && !field.index && !field.unique) {
+      issues.push({
+        severity: "info",
+        type: "missing_fk_index",
+        entity: entity.name,
+        field: fieldName,
+        message: `Foreign key field "${fieldName}" has no index`,
+        suggestion: 'Add "index: true" for better join performance'
+      });
+    }
+  }
+  return issues;
+}
+function checkUiMetadata(entity) {
+  const issues = [];
+  const systemFields = /* @__PURE__ */ new Set(["id", "created_at", "updated_at", "deleted_at", "tenant_id"]);
+  for (const [fieldName, field] of entity.fields) {
+    if (systemFields.has(fieldName)) continue;
+    const hasAnyUiMeta = field.ui.label !== void 0 || field.ui.type !== void 0 || field.ui.group !== void 0;
+    if (!hasAnyUiMeta) {
+      issues.push({
+        severity: "info",
+        type: "missing_ui_metadata",
+        entity: entity.name,
+        field: fieldName,
+        message: `Field "${fieldName}" has no UI metadata`,
+        suggestion: "Add ui_label, ui_type, ui_group for better admin panel display"
+      });
+    }
+  }
+  return issues;
+}
+function checkOrphanEntities(graph) {
+  const orphans = findOrphanEntities(graph);
+  return orphans.map((name) => ({
+    severity: "info",
+    type: "orphan_entity",
+    entity: name,
+    message: `Entity "${name}" has no relationships to other entities`,
+    suggestion: "Consider if this entity should be related to others"
+  }));
+}
+function checkCircularReferences(graph) {
+  const cycles = findCircularDependencies(graph);
+  return cycles.map((cycle) => ({
+    severity: "info",
+    type: "circular_dependency",
+    entity: cycle[0],
+    message: `Circular reference detected: ${cycle.join(" -> ")}`,
+    suggestion: "Verify this is intentional (e.g., self-referential hierarchy)"
+  }));
+}
+function checkMissingInverses(graph) {
+  const issues = [];
+  for (const edge of graph.edges) {
+    const { from, to, relationship } = edge;
+    const targetEntity = graph.entities.get(to);
+    if (!targetEntity) continue;
+    const hasInverse = Array.from(targetEntity.relationships.values()).some(
+      (rel) => rel.target === from
+    );
+    if (!hasInverse && relationship.type !== "belongs_to") {
+      issues.push({
+        severity: "info",
+        type: "missing_inverse",
+        entity: from,
+        field: relationship.name,
+        message: `Relationship "${relationship.name}" to "${to}" has no inverse defined on target`,
+        suggestion: `Add inverse relationship on "${to}" pointing back to "${from}"`
+      });
+    }
+  }
+  return issues;
+}
+function getAvailableFieldNames(entity) {
+  const entityFieldNames = Array.from(entity.fields.keys());
+  const behaviorFields = resolveBehaviorFields(entity.behaviors);
+  const behaviorFieldNames = behaviorFields.map((f) => f.name);
+  const belongsToFkNames = [];
+  for (const rel of entity.relationships.values()) {
+    if (rel.type === "belongs_to" && rel.foreignKey) {
+      belongsToFkNames.push(rel.foreignKey);
+    }
+  }
+  return [.../* @__PURE__ */ new Set([...entityFieldNames, ...behaviorFieldNames, ...belongsToFkNames])];
+}
+function checkQueryFieldReferences(entity) {
+  const issues = [];
+  const availableFields = getAvailableFieldNames(entity);
+  const availableSet = new Set(availableFields);
+  for (const query of entity.queries ?? []) {
+    if (!query.via) {
+      for (const fieldName of query.by) {
+        if (!availableSet.has(fieldName)) {
+          issues.push({
+            severity: "error",
+            type: "unknown_query_field",
+            entity: entity.name,
+            field: fieldName,
+            message: `Query references unknown field "${fieldName}" in entity "${entity.name}". Available fields: ${availableFields.join(", ")}`
+          });
+        }
+      }
+    }
+    for (const fieldName of query.select ?? []) {
+      if (!availableSet.has(fieldName)) {
+        issues.push({
+          severity: "error",
+          type: "unknown_query_field",
+          entity: entity.name,
+          field: fieldName,
+          message: `Query references unknown field "${fieldName}" in entity "${entity.name}". Available fields: ${availableFields.join(", ")}`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkSyncFieldMappingReferences(entity) {
+  const issues = [];
+  const availableFields = getAvailableFieldNames(entity);
+  const availableSet = new Set(availableFields);
+  for (const [providerName, provider] of Object.entries(entity.sync?.providers ?? {})) {
+    for (const fieldName of Object.keys(provider.fieldMapping ?? {})) {
+      if (!availableSet.has(fieldName)) {
+        issues.push({
+          severity: "warning",
+          type: "unknown_sync_field_mapping",
+          entity: entity.name,
+          field: fieldName,
+          message: `Sync field mapping references unknown field "${fieldName}" for provider "${providerName}" in entity "${entity.name}"`
+        });
+      }
+    }
+    for (const fieldName of provider.readOnlyFields ?? []) {
+      if (!availableSet.has(fieldName)) {
+        issues.push({
+          severity: "warning",
+          type: "unknown_sync_field_mapping",
+          entity: entity.name,
+          field: fieldName,
+          message: `Sync field mapping references unknown field "${fieldName}" for provider "${providerName}" in entity "${entity.name}"`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkExternalIdTrackingCollision(entity) {
+  const issues = [];
+  const hasExternalIdTracking = entity.behaviors.includes("external_id_tracking");
+  if (!hasExternalIdTracking) return issues;
+  for (const [providerName, provider] of Object.entries(entity.sync?.providers ?? {})) {
+    if (provider.fieldMapping && "external_id" in provider.fieldMapping) {
+      issues.push({
+        severity: "warning",
+        type: "external_id_tracking_collision",
+        entity: entity.name,
+        field: "external_id",
+        message: `Entity "${entity.name}" has external_id_tracking behavior and also maps "external_id" in sync field_mapping for provider "${providerName}". The behavior-added field may collide with the mapped field.`
+      });
+    }
+  }
+  return issues;
+}
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+
+// src/analyzer/statistics.ts
+function computeStatistics(graph) {
+  const entities = Array.from(graph.entities.values());
+  const fieldsByType = {};
+  const relationshipsByType = {};
+  let totalFields = 0;
+  let totalRelationships = 0;
+  let entitiesWithBehaviors = 0;
+  for (const entity of entities) {
+    totalFields += entity.fields.size;
+    totalRelationships += entity.relationships.size;
+    if (entity.behaviors.length > 0) {
+      entitiesWithBehaviors++;
+    }
+    for (const field of entity.fields.values()) {
+      fieldsByType[field.type] = (fieldsByType[field.type] ?? 0) + 1;
+    }
+    for (const rel of entity.relationships.values()) {
+      relationshipsByType[rel.type] = (relationshipsByType[rel.type] ?? 0) + 1;
+    }
+  }
+  return {
+    totalEntities: entities.length,
+    totalFields,
+    totalRelationships,
+    fieldsByType,
+    relationshipsByType,
+    entitiesWithBehaviors,
+    averageFieldsPerEntity: entities.length > 0 ? totalFields / entities.length : 0
+  };
+}
+
+// src/formatters/console-formatter.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m"
+};
+function color(text, ...styles) {
+  return `${styles.join("")}${text}${colors.reset}`;
+}
+function severityColor(severity) {
+  switch (severity) {
+    case "error":
+      return colors.red;
+    case "warning":
+      return colors.yellow;
+    case "info":
+      return colors.cyan;
+  }
+}
+function severityIcon(severity) {
+  switch (severity) {
+    case "error":
+      return "X";
+    case "warning":
+      return "!";
+    case "info":
+      return "i";
+  }
+}
+function formatConsole(result) {
+  const lines = [];
+  lines.push("");
+  lines.push(color("=".repeat(60), colors.dim));
+  lines.push(color("  Domain Analysis Report", colors.bold, colors.cyan));
+  lines.push(color("=".repeat(60), colors.dim));
+  lines.push("");
+  lines.push(...formatStatistics(result));
+  lines.push(...formatEntities(result));
+  lines.push(...formatRelationships(result));
+  if (result.issues.length > 0) {
+    lines.push(...formatIssues(result.issues));
+  }
+  lines.push("");
+  lines.push(color("-".repeat(60), colors.dim));
+  const errors = result.issues.filter((i) => i.severity === "error");
+  const warnings = result.issues.filter((i) => i.severity === "warning");
+  const infos = result.issues.filter((i) => i.severity === "info");
+  if (result.isValid) {
+    lines.push(
+      color(
+        `[OK] Domain is valid (${warnings.length} warnings, ${infos.length} info)`,
+        colors.green
+      )
+    );
+  } else {
+    lines.push(color(`[FAIL] Domain has ${errors.length} errors`, colors.red));
+  }
+  lines.push(color("-".repeat(60), colors.dim));
+  lines.push("");
+  return lines.join("\n");
+}
+function formatStatistics(result) {
+  const lines = [];
+  const stats = result.statistics;
+  lines.push(color("Statistics:", colors.bold));
+  lines.push("");
+  lines.push(`   Entities:        ${stats.totalEntities}`);
+  lines.push(
+    `   Fields:          ${stats.totalFields} (avg ${stats.averageFieldsPerEntity.toFixed(1)}/entity)`
+  );
+  lines.push(`   Relationships:   ${stats.totalRelationships}`);
+  lines.push(`   With behaviors:  ${stats.entitiesWithBehaviors}`);
+  lines.push("");
+  lines.push("   Field types:");
+  const sortedTypes = Object.entries(stats.fieldsByType).sort((a, b) => b[1] - a[1]);
+  for (const [type, count] of sortedTypes) {
+    const bar = color("|".repeat(Math.min(count, 20)), colors.blue);
+    lines.push(`     ${type.padEnd(12)} ${bar} ${count}`);
+  }
+  lines.push("");
+  if (stats.totalRelationships > 0) {
+    lines.push("   Relationship types:");
+    const sortedRels = Object.entries(stats.relationshipsByType).sort((a, b) => b[1] - a[1]);
+    for (const [type, count] of sortedRels) {
+      const bar = color("|".repeat(Math.min(count, 20)), colors.magenta);
+      lines.push(`     ${type.padEnd(12)} ${bar} ${count}`);
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function formatEntities(result) {
+  const lines = [];
+  lines.push(color("Entities:", colors.bold));
+  lines.push("");
+  for (const entity of result.entities) {
+    const fieldCount = entity.fields.size;
+    const relCount = entity.relationships.size;
+    lines.push(
+      `   ${color(entity.name, colors.cyan)} (${fieldCount} fields, ${relCount} relationships)`
+    );
+    if (entity.behaviors.length > 0) {
+      lines.push(color(`      behaviors: ${entity.behaviors.join(", ")}`, colors.dim));
+    }
+  }
+  lines.push("");
+  return lines;
+}
+function formatRelationships(result) {
+  const lines = [];
+  if (result.graph.edges.length === 0) {
+    return lines;
+  }
+  lines.push(color("Relationships:", colors.bold));
+  lines.push("");
+  for (const edge of result.graph.edges) {
+    const arrow = getCardinalityArrow(edge.cardinality);
+    const bidir = edge.bidirectional ? color(" (bidirectional)", colors.dim) : "";
+    lines.push(
+      `   ${edge.from.padEnd(20)} ${arrow} ${edge.to} ${color(`(${edge.relationship.type})`, colors.dim)}${bidir}`
+    );
+  }
+  lines.push("");
+  return lines;
+}
+function getCardinalityArrow(cardinality) {
+  switch (cardinality) {
+    case "1:N":
+      return color("--<", colors.magenta);
+    case "N:1":
+      return color(">--", colors.magenta);
+    case "1:1":
+      return color("---", colors.magenta);
+    case "N:M":
+      return color(">-<", colors.magenta);
+    default:
+      return color("-->", colors.magenta);
+  }
+}
+function formatIssues(issues) {
+  const lines = [];
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+  const infos = issues.filter((i) => i.severity === "info");
+  if (errors.length > 0) {
+    lines.push(color(`Errors (${errors.length}):`, colors.bold, colors.red));
+    lines.push("");
+    lines.push(...formatIssueList(errors, "error"));
+    lines.push("");
+  }
+  if (warnings.length > 0) {
+    lines.push(color(`Warnings (${warnings.length}):`, colors.bold, colors.yellow));
+    lines.push("");
+    lines.push(...formatIssueList(warnings, "warning"));
+    lines.push("");
+  }
+  if (infos.length > 0) {
+    lines.push(color(`Info (${infos.length}):`, colors.bold, colors.cyan));
+    lines.push("");
+    lines.push(...formatIssueList(infos, "info", 5));
+    lines.push("");
+  }
+  return lines;
+}
+function formatIssueList(issues, severity, limit) {
+  const lines = [];
+  const displayIssues = limit ? issues.slice(0, limit) : issues;
+  const byType = /* @__PURE__ */ new Map();
+  for (const issue of displayIssues) {
+    const list = byType.get(issue.type) ?? [];
+    list.push(issue);
+    byType.set(issue.type, list);
+  }
+  for (const [type, typeIssues] of byType) {
+    lines.push(color(`   ${type} (${typeIssues.length}):`, colors.dim));
+    for (const issue of typeIssues.slice(0, 5)) {
+      const location = issue.entity ? `${issue.entity}${issue.field ? "." + issue.field : ""}` : issue.path ?? "unknown";
+      const icon = color(`[${severityIcon(severity)}]`, severityColor(severity));
+      lines.push(`     ${icon} ${color(location, colors.bold)}: ${issue.message}`);
+      if (issue.suggestion) {
+        lines.push(color(`        -> ${issue.suggestion}`, colors.dim));
+      }
+    }
+    if (typeIssues.length > 5) {
+      lines.push(color(`     ... and ${typeIssues.length - 5} more`, colors.dim));
+    }
+  }
+  if (limit && issues.length > limit) {
+    lines.push(color(`   ... and ${issues.length - limit} more info messages`, colors.dim));
+  }
+  return lines;
+}
+
+// src/formatters/json-formatter.ts
+function mapToObject(map) {
+  const obj = {};
+  for (const [key, value] of map) {
+    obj[key] = value;
+  }
+  return obj;
+}
+function serializeEntity(entity) {
+  return {
+    name: entity.name,
+    plural: entity.plural,
+    table: entity.table,
+    folderStructure: entity.folderStructure,
+    fields: mapToObject(entity.fields),
+    relationships: mapToObject(entity.relationships),
+    behaviors: entity.behaviors,
+    sourcePath: entity.sourcePath
+  };
+}
+function serializeGraph(graph) {
+  const entities = {};
+  for (const [name, entity] of graph.entities) {
+    entities[name] = serializeEntity(entity);
+  }
+  return {
+    entities,
+    edges: graph.edges
+  };
+}
+function formatJson(result, pretty = true) {
+  const output = {
+    isValid: result.isValid,
+    summary: {
+      entities: result.statistics.totalEntities,
+      fields: result.statistics.totalFields,
+      relationships: result.statistics.totalRelationships,
+      errors: result.issues.filter((i) => i.severity === "error").length,
+      warnings: result.issues.filter((i) => i.severity === "warning").length,
+      info: result.issues.filter((i) => i.severity === "info").length
+    },
+    entities: result.entities.map(serializeEntity),
+    graph: serializeGraph(result.graph),
+    issues: result.issues,
+    statistics: result.statistics,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return pretty ? JSON.stringify(output, null, 2) : JSON.stringify(output);
+}
+
+// src/formatters/markdown-formatter.ts
+function formatMarkdown(result) {
+  const lines = [];
+  lines.push("# Domain Model Documentation");
+  lines.push("");
+  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("");
+  lines.push("## Overview");
+  lines.push("");
+  lines.push("| Metric | Value |");
+  lines.push("|--------|-------|");
+  lines.push(`| Entities | ${result.statistics.totalEntities} |`);
+  lines.push(`| Total Fields | ${result.statistics.totalFields} |`);
+  lines.push(`| Total Relationships | ${result.statistics.totalRelationships} |`);
+  lines.push(
+    `| Avg Fields/Entity | ${result.statistics.averageFieldsPerEntity.toFixed(1)} |`
+  );
+  lines.push("");
+  lines.push("### Field Type Distribution");
+  lines.push("");
+  lines.push("| Type | Count |");
+  lines.push("|------|-------|");
+  const sortedTypes = Object.entries(result.statistics.fieldsByType).sort(
+    (a, b) => b[1] - a[1]
+  );
+  for (const [type, count] of sortedTypes) {
+    lines.push(`| ${type} | ${count} |`);
+  }
+  lines.push("");
+  if (result.statistics.totalRelationships > 0) {
+    lines.push("### Relationship Type Distribution");
+    lines.push("");
+    lines.push("| Type | Count |");
+    lines.push("|------|-------|");
+    const sortedRels = Object.entries(result.statistics.relationshipsByType).sort(
+      (a, b) => b[1] - a[1]
+    );
+    for (const [type, count] of sortedRels) {
+      lines.push(`| ${type} | ${count} |`);
+    }
+    lines.push("");
+  }
+  lines.push("## Entity Relationship Diagram");
+  lines.push("");
+  lines.push("```mermaid");
+  lines.push(...generateMermaidErDiagram(result));
+  lines.push("```");
+  lines.push("");
+  lines.push("## Entities");
+  lines.push("");
+  for (const entity of result.entities) {
+    lines.push(...formatEntitySection(entity));
+  }
+  const errors = result.issues.filter((i) => i.severity === "error");
+  const warnings = result.issues.filter((i) => i.severity === "warning");
+  const infos = result.issues.filter((i) => i.severity === "info");
+  if (result.issues.length > 0) {
+    lines.push("## Analysis Issues");
+    lines.push("");
+    if (errors.length > 0) {
+      lines.push("### Errors");
+      lines.push("");
+      for (const issue of errors) {
+        const location = issue.entity ? `**${issue.entity}${issue.field ? "." + issue.field : ""}**` : issue.path ?? "unknown";
+        lines.push(`- [${issue.type}] ${location}: ${issue.message}`);
+        if (issue.suggestion) {
+          lines.push(`  - Suggestion: ${issue.suggestion}`);
+        }
+      }
+      lines.push("");
+    }
+    if (warnings.length > 0) {
+      lines.push("### Warnings");
+      lines.push("");
+      for (const issue of warnings) {
+        const location = issue.entity ? `**${issue.entity}${issue.field ? "." + issue.field : ""}**` : issue.path ?? "unknown";
+        lines.push(`- [${issue.type}] ${location}: ${issue.message}`);
+        if (issue.suggestion) {
+          lines.push(`  - Suggestion: ${issue.suggestion}`);
+        }
+      }
+      lines.push("");
+    }
+    if (infos.length > 0) {
+      lines.push("### Info");
+      lines.push("");
+      lines.push("<details>");
+      lines.push("<summary>Show info messages</summary>");
+      lines.push("");
+      for (const issue of infos) {
+        const location = issue.entity ? `**${issue.entity}${issue.field ? "." + issue.field : ""}**` : issue.path ?? "unknown";
+        lines.push(`- [${issue.type}] ${location}: ${issue.message}`);
+      }
+      lines.push("");
+      lines.push("</details>");
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function formatEntitySection(entity) {
+  const lines = [];
+  lines.push(`### ${entity.name}`);
+  lines.push("");
+  lines.push(`**Table:** \`${entity.table}\``);
+  lines.push(`**Plural:** ${entity.plural}`);
+  if (entity.behaviors.length > 0) {
+    lines.push(`**Behaviors:** ${entity.behaviors.join(", ")}`);
+  }
+  lines.push("");
+  lines.push("#### Fields");
+  lines.push("");
+  lines.push("| Name | Type | Required | Nullable | Index | Foreign Key |");
+  lines.push("|------|------|----------|----------|-------|-------------|");
+  for (const [name, field] of entity.fields) {
+    const required = field.required ? "Yes" : "";
+    const nullable = field.nullable ? "Yes" : "";
+    const index = field.index ? "Yes" : field.unique ? "Unique" : "";
+    const fk = field.foreignKey ? `${field.foreignKey.table}.${field.foreignKey.column}` : "";
+    lines.push(`| ${name} | ${field.type} | ${required} | ${nullable} | ${index} | ${fk} |`);
+  }
+  lines.push("");
+  if (entity.relationships.size > 0) {
+    lines.push("#### Relationships");
+    lines.push("");
+    lines.push("| Name | Type | Target | Foreign Key |");
+    lines.push("|------|------|--------|-------------|");
+    for (const [name, rel] of entity.relationships) {
+      lines.push(`| ${name} | ${rel.type} | ${rel.target} | ${rel.foreignKey} |`);
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function generateMermaidErDiagram(result) {
+  const lines = [];
+  lines.push("erDiagram");
+  for (const entity of result.entities) {
+    const entityName = entity.name.toUpperCase();
+    lines.push(`    ${entityName} {`);
+    const keyFields = Array.from(entity.fields.entries()).filter(
+      ([name, field]) => field.foreignKey || field.unique || field.index || name === "id" || name === "name"
+    ).slice(0, 6);
+    for (const [name, field] of keyFields) {
+      const typeStr = field.type;
+      const pk = name === "id" ? "PK" : "";
+      const fk = field.foreignKey ? "FK" : "";
+      const marker = pk || fk ? ` "${pk}${fk}"` : "";
+      lines.push(`        ${typeStr} ${name}${marker}`);
+    }
+    if (entity.fields.size > keyFields.length) {
+      lines.push(`        string _more_fields`);
+    }
+    lines.push("    }");
+  }
+  for (const edge of result.graph.edges) {
+    const from = edge.from.toUpperCase();
+    const to = edge.to.toUpperCase();
+    const cardinalitySymbol = getCardinalitySymbol(edge.cardinality);
+    const label = edge.relationship.name;
+    lines.push(`    ${from} ${cardinalitySymbol} ${to} : "${label}"`);
+  }
+  return lines;
+}
+function getCardinalitySymbol(cardinality) {
+  switch (cardinality) {
+    case "1:N":
+      return "||--o{";
+    case "N:1":
+      return "}o--||";
+    case "1:1":
+      return "||--||";
+    case "N:M":
+      return "}o--o{";
+    default:
+      return "||--o{";
+  }
+}
+function formatMermaidGraph(result) {
+  const lines = [];
+  lines.push("```mermaid");
+  lines.push("graph LR");
+  lines.push("    classDef entity fill:#e1f5fe,stroke:#01579b");
+  for (const entity of result.entities) {
+    lines.push(`    ${entity.name}["${entity.name}\\n(${entity.fields.size} fields)"]`);
+  }
+  for (const edge of result.graph.edges) {
+    const style = edge.bidirectional ? "<-->" : "-->";
+    lines.push(`    ${edge.from} ${style}|${edge.relationship.type}| ${edge.to}`);
+  }
+  const entityList = result.entities.map((e) => e.name).join(",");
+  if (entityList) {
+    lines.push(`    class ${entityList} entity`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+
+// src/index.ts
+async function analyzeDomain(entitiesDir, relationshipsDir) {
+  const { entities, issues: loadIssues } = loadEntities(entitiesDir);
+  const { relationships: relationshipDefinitions, issues: relLoadIssues } = relationshipsDir ? loadRelationships(relationshipsDir) : { relationships: [], issues: [] };
+  const resolveIssues = resolveReferences(entities);
+  const relResolveIssues = resolveRelationshipReferences(
+    relationshipDefinitions,
+    entities
+  );
+  const graph = buildDomainGraph(entities, relationshipDefinitions);
+  const consistencyIssues = checkConsistency(graph);
+  const statistics = computeStatistics(graph);
+  const allIssues = [
+    ...loadIssues,
+    ...relLoadIssues,
+    ...resolveIssues,
+    ...relResolveIssues,
+    ...consistencyIssues
+  ];
+  const hasErrors = allIssues.some((i) => i.severity === "error");
+  return {
+    isValid: !hasErrors,
+    entities,
+    relationshipDefinitions,
+    graph,
+    issues: allIssues,
+    statistics
+  };
+}
+function validateEntities(entitiesDir) {
+  const { entities, issues } = loadEntities(entitiesDir);
+  const errors = issues.filter((i) => i.severity === "error").map((i) => i.message);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+export {
+  analyzeDomain,
+  buildDomainGraph,
+  checkConsistency,
+  computeStatistics,
+  findCircularDependencies,
+  findOrphanEntities,
+  formatConsole,
+  formatJson,
+  formatMarkdown,
+  formatMermaidGraph,
+  getRelatedEntities,
+  loadEntities,
+  loadEntityFromYaml,
+  loadRelationshipFromYaml,
+  loadRelationships,
+  validateEntities
+};
+//# sourceMappingURL=index.js.map