yamchart 0.3.1 → 0.3.4

package/dist/chunk-A24KVXJQ.js

@@ -0,0 +1,922 @@
+import {
+  parseModelMetadata
+} from "./chunk-LL3VKMZM.js";
+
+// src/commands/validate.ts
+import { readFile, readdir, access } from "fs/promises";
+import { join, extname, relative } from "path";
+import { parse as parseYaml } from "yaml";
+
+// ../../packages/schema/dist/connection.js
+import { z } from "zod";
+var EnvAuthSchema = z.object({
+  type: z.literal("env"),
+  user_var: z.string(),
+  password_var: z.string()
+});
+var KeyPairAuthSchema = z.object({
+  type: z.literal("key_pair"),
+  user_var: z.string(),
+  private_key_path: z.string()
+});
+var SecretManagerAuthSchema = z.object({
+  type: z.literal("secret_manager"),
+  provider: z.enum(["aws_secrets_manager", "gcp_secret_manager", "vault"]),
+  secret_id: z.string()
+});
+var AuthSchema = z.discriminatedUnion("type", [
+  EnvAuthSchema,
+  KeyPairAuthSchema,
+  SecretManagerAuthSchema
+]);
+var PoolConfigSchema = z.object({
+  min_connections: z.number().int().positive().optional(),
+  max_connections: z.number().int().positive().optional(),
+  idle_timeout: z.number().int().positive().optional()
+});
+var QueryConfigSchema = z.object({
+  timeout: z.number().int().positive().optional(),
+  max_rows: z.number().int().positive().optional()
+});
+var DuckDBConfigSchema = z.object({
+  path: z.string()
+  // file path or :memory:
+});
+var PostgresConfigSchema = z.object({
+  host: z.string(),
+  port: z.number().int().positive().default(5432),
+  database: z.string(),
+  schema: z.string().optional(),
+  ssl: z.boolean().optional()
+});
+var SnowflakeConfigSchema = z.object({
+  account: z.string(),
+  warehouse: z.string(),
+  database: z.string(),
+  schema: z.string().optional(),
+  role: z.string().optional()
+});
+var MySQLConfigSchema = z.object({
+  host: z.string(),
+  port: z.number().int().positive().default(3306),
+  database: z.string(),
+  ssl: z.boolean().optional()
+});
+var SQLiteConfigSchema = z.object({
+  path: z.string()
+  // file path or :memory:
+});
+var BaseConnectionSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().optional(),
+  pool: PoolConfigSchema.optional(),
+  query: QueryConfigSchema.optional()
+});
+var DuckDBConnectionSchema = BaseConnectionSchema.extend({
+  type: z.literal("duckdb"),
+  config: DuckDBConfigSchema,
+  auth: z.undefined().optional()
+});
+var PostgresConnectionSchema = BaseConnectionSchema.extend({
+  type: z.literal("postgres"),
+  config: PostgresConfigSchema,
+  auth: AuthSchema.optional()
+});
+var SnowflakeConnectionSchema = BaseConnectionSchema.extend({
+  type: z.literal("snowflake"),
+  config: SnowflakeConfigSchema,
+  auth: AuthSchema
+});
+var MySQLConnectionSchema = BaseConnectionSchema.extend({
+  type: z.literal("mysql"),
+  config: MySQLConfigSchema,
+  auth: AuthSchema.optional()
+});
+var SQLiteConnectionSchema = BaseConnectionSchema.extend({
+  type: z.literal("sqlite"),
+  config: SQLiteConfigSchema,
+  auth: z.undefined().optional()
+});
+var ConnectionSchema = z.discriminatedUnion("type", [
+  DuckDBConnectionSchema,
+  PostgresConnectionSchema,
+  SnowflakeConnectionSchema,
+  MySQLConnectionSchema,
+  SQLiteConnectionSchema
+]);
+
+// ../../packages/schema/dist/chart.js
+import { z as z2 } from "zod";
+var AxisTypeSchema = z2.enum(["temporal", "quantitative", "ordinal", "nominal"]);
+var AxisSchema = z2.object({
+  field: z2.string().min(1),
+  type: AxisTypeSchema,
+  format: z2.string().optional(),
+  label: z2.string().optional()
+});
+var ChartTypeSchema = z2.enum([
+  "line",
+  "bar",
+  "area",
+  "pie",
+  "donut",
+  "table",
+  "metric",
+  "map",
+  "heatmap",
+  "funnel",
+  "sankey",
+  "treemap",
+  "waterfall",
+  "gauge"
+]);
+var GradientSchema = z2.union([
+  z2.boolean(),
+  z2.object({
+    from: z2.string(),
+    to: z2.string()
+  })
+]);
+var LongFormatSeriesSchema = z2.object({
+  field: z2.string().min(1),
+  colors: z2.record(z2.string(), z2.string()).optional()
+});
+var WideFormatColumnSchema = z2.object({
+  field: z2.string().min(1),
+  name: z2.string().optional(),
+  type: z2.enum(["line", "bar", "area"]).optional(),
+  axis: z2.enum(["left", "right"]).optional(),
+  color: z2.string().optional(),
+  style: z2.enum(["solid", "dashed", "dotted"]).optional(),
+  opacity: z2.number().min(0).max(1).optional(),
+  gradient: GradientSchema.optional()
+});
+var WideFormatSeriesSchema = z2.object({
+  columns: z2.array(WideFormatColumnSchema).min(1)
+});
+var SeriesConfigSchema = z2.union([
+  LongFormatSeriesSchema,
+  WideFormatSeriesSchema
+]);
+var ColorConditionSchema = z2.object({
+  when: z2.string(),
+  color: z2.string()
+});
+var ConditionalColorSchema = z2.object({
+  conditions: z2.array(ColorConditionSchema).min(1),
+  default: z2.string().optional()
+});
+var ColorSchema = z2.union([
+  z2.string(),
+  ConditionalColorSchema
+]);
+var LegendSchema = z2.object({
+  show: z2.boolean().optional(),
+  position: z2.enum(["top", "bottom", "left", "right"]).optional()
+});
+var LineAnnotationSchema = z2.object({
+  type: z2.literal("line"),
+  value: z2.number(),
+  label: z2.string().optional(),
+  color: z2.string().optional(),
+  style: z2.enum(["solid", "dashed", "dotted"]).optional()
+});
+var BandAnnotationSchema = z2.object({
+  type: z2.literal("band"),
+  from: z2.number(),
+  to: z2.number(),
+  label: z2.string().optional(),
+  color: z2.string().optional()
+});
+var AnnotationSchema = z2.discriminatedUnion("type", [
+  LineAnnotationSchema,
+  BandAnnotationSchema
+]);
+var InteractionsSchema = z2.object({
+  tooltip: z2.boolean().default(true),
+  zoom: z2.boolean().default(false),
+  brush: z2.boolean().default(false)
+});
+var KpiFormatSchema = z2.object({
+  type: z2.enum(["number", "currency", "percent"]),
+  currency: z2.string().optional(),
+  // e.g., 'USD', 'EUR'
+  decimals: z2.number().optional()
+});
+var KpiComparisonSchema = z2.object({
+  enabled: z2.boolean(),
+  field: z2.string().min(1),
+  label: z2.string().optional(),
+  type: z2.enum(["percent_change", "absolute"])
+});
+var KpiValueSchema = z2.object({
+  field: z2.string().min(1)
+});
+var KpiConfigSchema = z2.object({
+  type: z2.literal("kpi"),
+  value: KpiValueSchema,
+  format: KpiFormatSchema,
+  comparison: KpiComparisonSchema.optional()
+});
+var CenterValueSchema = z2.object({
+  field: z2.string().optional(),
+  // 'total' for sum, or specific field
+  label: z2.string().optional(),
+  format: z2.string().optional()
+});
+var StandardChartConfigSchema = z2.object({
+  type: ChartTypeSchema,
+  x: AxisSchema,
+  y: AxisSchema.optional(),
+  series: SeriesConfigSchema.optional(),
+  stacking: z2.enum(["stacked", "percent"]).optional(),
+  color: ColorSchema.optional(),
+  gradient: GradientSchema.optional(),
+  legend: LegendSchema.optional(),
+  annotations: z2.array(AnnotationSchema).optional(),
+  interactions: InteractionsSchema.optional(),
+  centerValue: CenterValueSchema.optional()
+  // For donut charts
+});
+var DualAxesSchema = z2.object({
+  left: AxisSchema.optional(),
+  right: AxisSchema.optional()
+});
+var ComboChartConfigSchema = z2.object({
+  type: z2.literal("combo"),
+  x: AxisSchema,
+  series: WideFormatSeriesSchema,
+  axes: DualAxesSchema,
+  legend: LegendSchema.optional(),
+  interactions: InteractionsSchema.optional(),
+  gradient: GradientSchema.optional()
+});
+var ScatterSizeSchema = z2.object({
+  field: z2.string().min(1),
+  min: z2.number().optional(),
+  max: z2.number().optional(),
+  label: z2.string().optional()
+});
+var ScatterGroupSchema = z2.object({
+  field: z2.string().min(1)
+});
+var RegressionSchema = z2.object({
+  type: z2.literal("linear"),
+  show_equation: z2.boolean().optional(),
+  show_r_squared: z2.boolean().optional()
+});
+var ScatterChartConfigSchema = z2.object({
+  type: z2.literal("scatter"),
+  x: AxisSchema,
+  y: AxisSchema,
+  size: ScatterSizeSchema.optional(),
+  group: ScatterGroupSchema.optional(),
+  regression: RegressionSchema.optional(),
+  color: ColorSchema.optional(),
+  legend: LegendSchema.optional(),
+  interactions: InteractionsSchema.optional()
+});
+var HeatmapChartConfigSchema = z2.object({
+  type: z2.literal("heatmap"),
+  x: AxisSchema,
+  y: AxisSchema,
+  value: z2.object({
+    field: z2.string().min(1),
+    label: z2.string().optional()
+  }),
+  color_range: z2.object({
+    min: z2.string().optional(),
+    max: z2.string().optional()
+  }).optional(),
+  show_values: z2.boolean().optional()
+});
+var FunnelChartConfigSchema = z2.object({
+  type: z2.literal("funnel"),
+  stage: z2.object({ field: z2.string().min(1) }),
+  value: z2.object({ field: z2.string().min(1) }),
+  show_conversion: z2.boolean().optional(),
+  color: ColorSchema.optional()
+});
+var WaterfallChartConfigSchema = z2.object({
+  type: z2.literal("waterfall"),
+  category: z2.object({ field: z2.string().min(1) }),
+  value: z2.object({ field: z2.string().min(1) }),
+  total_field: z2.string().optional(),
+  colors: z2.object({
+    increase: z2.string().optional(),
+    decrease: z2.string().optional(),
+    total: z2.string().optional()
+  }).optional()
+});
+var GaugeThresholdSchema = z2.object({
+  value: z2.number(),
+  color: z2.string()
+});
+var GaugeChartConfigSchema = z2.object({
+  type: z2.literal("gauge"),
+  value: z2.object({ field: z2.string().min(1) }),
+  min: z2.number().optional(),
+  max: z2.number().optional(),
+  thresholds: z2.array(GaugeThresholdSchema).optional(),
+  format: z2.string().optional()
+});
+var ChartConfigSchema = z2.union([
+  ScatterChartConfigSchema,
+  ComboChartConfigSchema,
+  HeatmapChartConfigSchema,
+  FunnelChartConfigSchema,
+  WaterfallChartConfigSchema,
+  GaugeChartConfigSchema,
+  StandardChartConfigSchema,
+  KpiConfigSchema
+]);
+var ParameterTypeSchema = z2.enum([
+  "date_range",
+  "select",
+  "multi_select",
+  "dynamic_select",
+  "text",
+  "number"
+]);
+var ParameterOptionSchema = z2.union([
+  z2.string(),
+  z2.object({
+    value: z2.string(),
+    label: z2.string()
+  })
+]);
+var ParameterSourceSchema = z2.object({
+  model: z2.string(),
+  value_field: z2.string(),
+  label_field: z2.string()
+});
+var ParameterSchema = z2.object({
+  name: z2.string().min(1),
+  type: ParameterTypeSchema,
+  label: z2.string().optional(),
+  default: z2.union([z2.string(), z2.number(), z2.array(z2.string())]).optional(),
+  options: z2.array(ParameterOptionSchema).optional(),
+  source: ParameterSourceSchema.optional()
+});
+var SourceSchema = z2.object({
+  model: z2.string().optional(),
+  sql: z2.string().optional()
+}).refine((data) => data.model !== void 0 || data.sql !== void 0, { message: "Source must specify either model or sql" }).refine((data) => !(data.model !== void 0 && data.sql !== void 0), { message: "Source cannot specify both model and sql" });
+var RefreshSchema = z2.object({
+  schedule: z2.string().optional(),
+  // cron expression
+  timezone: z2.string().optional(),
+  cache_ttl: z2.string().optional()
+  // e.g., "1h", "30m"
+});
+var DrillDownColumnSchema = z2.object({
+  field: z2.string().min(1),
+  label: z2.string().optional(),
+  format: z2.string().optional()
+});
+var DrillDownConfigSchema = z2.object({
+  chart: z2.string().optional(),
+  // target chart name (source side)
+  field: z2.string().optional(),
+  // field to pass as filter, defaults to x-axis field
+  columns: z2.array(DrillDownColumnSchema).optional()
+  // data table columns (target side)
+});
+var ChartSchema = z2.object({
+  // Identity
+  name: z2.string().min(1),
+  title: z2.string().min(1),
+  description: z2.string().optional(),
+  // Metadata
+  owner: z2.string().optional(),
+  tags: z2.array(z2.string()).optional(),
+  created: z2.string().optional(),
+  updated: z2.string().optional(),
+  // Data
+  source: SourceSchema,
+  parameters: z2.array(ParameterSchema).optional(),
+  // Visualization
+  chart: ChartConfigSchema,
+  // Caching
+  refresh: RefreshSchema.optional(),
+  // Drill-down navigation
+  drillDown: DrillDownConfigSchema.optional()
+});
+
+// ../../packages/schema/dist/project.js
+import { z as z3 } from "zod";
+var DefaultsSchema = z3.object({
+  connection: z3.string().optional(),
+  theme: z3.string().optional(),
+  timezone: z3.string().optional(),
+  cache_ttl: z3.string().optional(),
+  base_url: z3.string().url().optional()
+});
+var EnvironmentSchema = z3.object({
+  connection: z3.string().optional(),
+  base_url: z3.string().url().optional()
+});
+var GitSchema = z3.object({
+  provider: z3.enum(["github", "gitlab", "bitbucket"]).optional(),
+  repo: z3.string().optional(),
+  branch: z3.string().optional(),
+  preview_branches: z3.boolean().optional()
+});
+var SSOProviderSchema = z3.object({
+  client_id: z3.string(),
+  client_secret: z3.string(),
+  tenant: z3.string().optional(),
+  issuer: z3.string().optional(),
+  display_name: z3.string().optional()
+});
+var AuthSchema2 = z3.object({
+  enabled: z3.boolean(),
+  db_path: z3.string().optional(),
+  session_ttl: z3.string().optional(),
+  providers: z3.object({
+    google: SSOProviderSchema.optional(),
+    microsoft: SSOProviderSchema.optional(),
+    oidc: SSOProviderSchema.optional()
+  }).optional()
+});
+var FeaturesSchema = z3.object({
+  enable_sql_editor: z3.boolean().optional(),
+  enable_csv_export: z3.boolean().optional(),
+  enable_scheduling: z3.boolean().optional()
+});
+var ThemeSchema = z3.object({
+  palette: z3.array(z3.string()).optional(),
+  gradient: z3.boolean().default(false),
+  opacity: z3.number().min(0).max(1).default(1)
+});
+var ProjectSchema = z3.object({
+  version: z3.string().min(1),
+  name: z3.string().min(1),
+  description: z3.string().optional(),
+  defaults: DefaultsSchema.optional(),
+  environments: z3.record(z3.string(), EnvironmentSchema).optional(),
+  git: GitSchema.optional(),
+  auth: AuthSchema2.optional(),
+  features: FeaturesSchema.optional(),
+  theme: ThemeSchema.optional()
+});
+
+// ../../packages/schema/dist/model.js
+import { z as z4 } from "zod";
+var ParamTypeSchema = z4.enum(["string", "number", "date", "boolean", "string[]", "number[]"]);
+var ModelParamSchema = z4.object({
+  name: z4.string().min(1),
+  type: ParamTypeSchema,
+  default: z4.string().optional(),
+  options: z4.array(z4.string()).optional(),
+  // For enum-like params
+  description: z4.string().optional()
+});
+var ReturnColumnSchema = z4.object({
+  name: z4.string().min(1),
+  type: z4.string(),
+  description: z4.string().optional()
+});
+var ModelMetadataSchema = z4.object({
+  name: z4.string().min(1),
+  description: z4.string().optional(),
+  owner: z4.string().optional(),
+  tags: z4.array(z4.string()).optional(),
+  params: z4.array(ModelParamSchema).optional(),
+  returns: z4.array(ReturnColumnSchema).optional(),
+  tests: z4.array(z4.string()).optional()
+  // SQL assertions
+});
+var ModelSchema = z4.object({
+  metadata: ModelMetadataSchema,
+  sql: z4.string().min(1),
+  filePath: z4.string().optional()
+});
+
+// ../../packages/schema/dist/dashboard.js
+import { z as z5 } from "zod";
+var ChartWidgetSchema = z5.object({
+  type: z5.literal("chart"),
+  ref: z5.string().min(1),
+  cols: z5.number().min(1).max(12)
+});
+var TextWidgetSchema = z5.object({
+  type: z5.literal("text"),
+  content: z5.string().min(1),
+  cols: z5.number().min(1).max(12)
+});
+var WidgetSchema = z5.discriminatedUnion("type", [
+  ChartWidgetSchema,
+  TextWidgetSchema
+]);
+var RowSchema = z5.object({
+  height: z5.number().min(50),
+  widgets: z5.array(WidgetSchema).min(1)
+});
+var LayoutSchema = z5.object({
+  gap: z5.number().min(0).default(16),
+  rows: z5.array(RowSchema).min(1)
+});
+var DashboardSchema = z5.object({
+  // Identity
+  name: z5.string().min(1),
+  title: z5.string().min(1),
+  description: z5.string().optional(),
+  // Filters inherited by all widgets
+  filters: z5.array(ParameterSchema).optional(),
+  // Layout definition
+  layout: LayoutSchema
+});
+
+// ../../packages/schema/dist/schedule.js
+import { z as z6 } from "zod";
+var SlackChannelSchema = z6.object({
+  webhook_url: z6.string().min(1),
+  channel: z6.string().optional()
+});
+var ChannelSchema = z6.object({
+  slack: SlackChannelSchema
+});
+var ConditionOperatorSchema = z6.enum(["lt", "gt", "lte", "gte", "eq"]);
+var ConditionSchema = z6.object({
+  field: z6.string().min(1),
+  operator: ConditionOperatorSchema,
+  value: z6.number()
+});
+var ReportScheduleSchema = z6.object({
+  name: z6.string().min(1),
+  type: z6.literal("report"),
+  schedule: z6.string().min(1),
+  timezone: z6.string().optional(),
+  channel: ChannelSchema,
+  charts: z6.array(z6.string().min(1)).min(1),
+  params: z6.record(z6.unknown()).optional(),
+  message: z6.string().optional(),
+  notify_on_error: z6.boolean().optional()
+});
+var AlertScheduleSchema = z6.object({
+  name: z6.string().min(1),
+  type: z6.literal("alert"),
+  schedule: z6.string().min(1),
+  timezone: z6.string().optional(),
+  channel: ChannelSchema,
+  chart: z6.string().min(1),
+  params: z6.record(z6.unknown()).optional(),
+  condition: ConditionSchema,
+  cooldown: z6.string().optional(),
+  message: z6.string().optional(),
+  notify_on_error: z6.boolean().optional()
+});
+var ScheduleSchema = z6.discriminatedUnion("type", [
+  ReportScheduleSchema,
+  AlertScheduleSchema
+]);
+
+// src/commands/validate.ts
+async function validateProject(projectDir, options) {
+  const errors = [];
+  const warnings = [];
+  let filesChecked = 0;
+  let filesPassed = 0;
+  const config = {
+    project: null,
+    connections: /* @__PURE__ */ new Map(),
+    models: /* @__PURE__ */ new Map(),
+    charts: /* @__PURE__ */ new Map(),
+    dashboards: /* @__PURE__ */ new Map(),
+    schedules: /* @__PURE__ */ new Map()
+  };
+  const projectPath = join(projectDir, "yamchart.yaml");
+  try {
+    await access(projectPath);
+    filesChecked++;
+    const content = await readFile(projectPath, "utf-8");
+    const parsed = parseYaml(content);
+    const result = ProjectSchema.safeParse(parsed);
+    if (result.success) {
+      config.project = result.data;
+      filesPassed++;
+    } else {
+      errors.push({
+        file: "yamchart.yaml",
+        message: `Invalid schema: ${result.error.errors[0]?.message || "Unknown error"}`
+      });
+    }
+  } catch {
+    errors.push({
+      file: "yamchart.yaml",
+      message: "yamchart.yaml not found"
+    });
+    return {
+      success: false,
+      errors,
+      warnings,
+      stats: { files: filesChecked, passed: filesPassed, failed: filesChecked - filesPassed }
+    };
+  }
+  const connectionsDir = join(projectDir, "connections");
+  try {
+    await access(connectionsDir);
+    const files = await readdir(connectionsDir);
+    for (const file of files) {
+      if (extname(file) !== ".yaml" && extname(file) !== ".yml") continue;
+      filesChecked++;
+      const filePath = join(connectionsDir, file);
+      const content = await readFile(filePath, "utf-8");
+      const parsed = parseYaml(content);
+      const result = ConnectionSchema.safeParse(parsed);
+      if (result.success) {
+        config.connections.set(result.data.name, result.data);
+        filesPassed++;
+      } else {
+        errors.push({
+          file: `connections/${file}`,
+          message: `Invalid schema: ${result.error.errors[0]?.message || "Unknown error"}`
+        });
+      }
+    }
+  } catch {
+  }
+  const modelsDir = join(projectDir, "models");
+  const modelStats = { filesChecked: 0, filesPassed: 0 };
+  try {
+    await access(modelsDir);
+    await validateModelsDir(modelsDir, projectDir, config, errors, modelStats);
+    filesChecked += modelStats.filesChecked;
+    filesPassed += modelStats.filesPassed;
+  } catch {
+  }
+  const chartsDir = join(projectDir, "charts");
+  try {
+    await access(chartsDir);
+    const files = await readdir(chartsDir);
+    for (const file of files) {
+      if (extname(file) !== ".yaml" && extname(file) !== ".yml") continue;
+      filesChecked++;
+      const filePath = join(chartsDir, file);
+      const content = await readFile(filePath, "utf-8");
+      const parsed = parseYaml(content);
+      const result = ChartSchema.safeParse(parsed);
+      if (result.success) {
+        config.charts.set(result.data.name, result.data);
+        filesPassed++;
+      } else {
+        errors.push({
+          file: `charts/${file}`,
+          message: `Invalid schema: ${result.error.errors[0]?.message || "Unknown error"}`
+        });
+      }
+    }
+  } catch {
+  }
+  const dashboardsDir = join(projectDir, "dashboards");
+  try {
+    await access(dashboardsDir);
+    const files = await readdir(dashboardsDir);
+    for (const file of files) {
+      if (extname(file) !== ".yaml" && extname(file) !== ".yml") continue;
+      filesChecked++;
+      const filePath = join(dashboardsDir, file);
+      const content = await readFile(filePath, "utf-8");
+      const parsed = parseYaml(content);
+      const result = DashboardSchema.safeParse(parsed);
+      if (result.success) {
+        config.dashboards.set(result.data.name, result.data);
+        filesPassed++;
+      } else {
+        errors.push({
+          file: `dashboards/${file}`,
+          message: `Invalid schema: ${result.error.errors[0]?.message || "Unknown error"}`
+        });
+      }
+    }
+  } catch {
+  }
+  const schedulesDir = join(projectDir, "schedules");
+  try {
+    await access(schedulesDir);
+    const files = await readdir(schedulesDir);
+    for (const file of files) {
+      if (extname(file) !== ".yaml" && extname(file) !== ".yml") continue;
+      filesChecked++;
+      const filePath = join(schedulesDir, file);
+      const content = await readFile(filePath, "utf-8");
+      const parsed = parseYaml(content);
+      const result = ScheduleSchema.safeParse(parsed);
+      if (result.success) {
+        config.schedules.set(result.data.name, result.data);
+        filesPassed++;
+      } else {
+        errors.push({
+          file: `schedules/${file}`,
+          message: `Invalid schema: ${result.error.errors[0]?.message || "Unknown error"}`
+        });
+      }
+    }
+  } catch {
+  }
+  crossReferenceValidation(config, errors, warnings);
+  let dryRunStats;
+  if (options.dryRun) {
+    dryRunStats = await dryRunValidation(projectDir, config, options.connection, errors);
+  }
+  return {
+    success: errors.length === 0,
+    errors,
+    warnings,
+    stats: {
+      files: filesChecked,
+      passed: filesPassed,
+      failed: filesChecked - filesPassed
+    },
+    dryRunStats
+  };
+}
+async function validateModelsDir(dir, projectDir, config, errors, stats) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await validateModelsDir(fullPath, projectDir, config, errors, stats);
+    } else if (extname(entry.name) === ".sql") {
+      stats.filesChecked++;
+      const relPath = relative(projectDir, fullPath);
+      const content = await readFile(fullPath, "utf-8");
+      try {
+        const parsed = parseModelMetadata(content);
+        config.models.set(parsed.name, { name: parsed.name, sql: parsed.sql });
+        stats.filesPassed++;
+      } catch (err) {
+        errors.push({
+          file: relPath,
+          message: err instanceof Error ? err.message : "Failed to parse model"
+        });
+      }
+    }
+  }
+}
+function crossReferenceValidation(config, errors, warnings) {
+  for (const [chartName, chart] of config.charts) {
+    if (chart.source.model && !config.models.has(chart.source.model)) {
+      const suggestion = findSimilar(chart.source.model, Array.from(config.models.keys()));
+      errors.push({
+        file: `charts/${chartName}.yaml`,
+        message: `Unknown model reference "${chart.source.model}"`,
+        suggestion: suggestion ? `Did you mean "${suggestion}"?` : void 0
+      });
+    }
+  }
+  for (const [scheduleName, schedule] of config.schedules) {
+    const chartNames = schedule.type === "report" ? schedule.charts : [schedule.chart];
+    for (const chartName of chartNames) {
+      if (!config.charts.has(chartName)) {
+        const suggestion = findSimilar(chartName, Array.from(config.charts.keys()));
+        warnings.push({
+          file: `schedules/${scheduleName}.yaml`,
+          message: `Unknown chart reference "${chartName}"`,
+          suggestion: suggestion ? `Did you mean "${suggestion}"?` : void 0
+        });
+      }
+    }
+    const cronFields = schedule.schedule.trim().split(/\s+/);
+    if (cronFields.length < 5 || cronFields.length > 6) {
+      errors.push({
+        file: `schedules/${scheduleName}.yaml`,
+        message: `Invalid cron expression "${schedule.schedule}" (expected 5-6 fields)`
+      });
+    }
+  }
+  if (config.project?.defaults?.connection) {
+    const connName = config.project.defaults.connection;
+    if (!config.connections.has(connName)) {
+      const suggestion = findSimilar(connName, Array.from(config.connections.keys()));
+      errors.push({
+        file: "yamchart.yaml",
+        message: `Default connection "${connName}" not found`,
+        suggestion: suggestion ? `Did you mean "${suggestion}"?` : void 0
+      });
+    }
+  }
+}
+function findSimilar(target, candidates) {
+  const threshold = 3;
+  for (const candidate of candidates) {
+    if (levenshtein(target.toLowerCase(), candidate.toLowerCase()) <= threshold) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function levenshtein(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+async function dryRunValidation(projectDir, config, connectionName, errors) {
+  const { DuckDBConnector } = await import("./dist-JKJLH3F6.js");
+  let passed = 0;
+  let failed = 0;
+  const connName = connectionName || config.project?.defaults?.connection;
+  if (!connName) {
+    errors.push({
+      file: "yamchart.yaml",
+      message: "No connection specified for dry-run (use --connection or set defaults.connection)"
+    });
+    return { passed, failed: 1 };
+  }
+  const connection = config.connections.get(connName);
+  if (!connection) {
+    errors.push({
+      file: "yamchart.yaml",
+      message: `Connection "${connName}" not found`
+    });
+    return { passed, failed: 1 };
+  }
+  if (connection.type !== "duckdb") {
+    errors.push({
+      file: `connections/${connName}.yaml`,
+      message: `Dry-run not yet supported for connection type "${connection.type}"`
+    });
+    return { passed, failed: 1 };
+  }
+  const connPath = join(projectDir, "connections", `${connName}.yaml`);
+  const connContent = await readFile(connPath, "utf-8");
+  const connConfig = parseYaml(connContent);
+  const dbPath = connConfig.config.path.startsWith("/") ? connConfig.config.path : join(projectDir, connConfig.config.path);
+  const connector = new DuckDBConnector({ path: dbPath });
+  try {
+    await connector.connect();
+    for (const [modelName, model] of config.models) {
+      const result = await connector.explain(model.sql);
+      if (result.valid) {
+        passed++;
+      } else {
+        failed++;
+        errors.push({
+          file: `models/${modelName}.sql`,
+          message: result.error || "Query validation failed"
+        });
+      }
+    }
+  } finally {
+    await connector.disconnect();
+  }
+  return { passed, failed };
+}
+
+// src/utils/config.ts
+import { access as access2 } from "fs/promises";
+import { join as join2, dirname, resolve } from "path";
+import { config as loadDotenv } from "dotenv";
+async function findProjectRoot(startDir) {
+  let currentDir = resolve(startDir);
+  const root = dirname(currentDir);
+  while (currentDir !== root) {
+    const configPath = join2(currentDir, "yamchart.yaml");
+    try {
+      await access2(configPath);
+      return currentDir;
+    } catch {
+      currentDir = dirname(currentDir);
+    }
+  }
+  try {
+    await access2(join2(root, "yamchart.yaml"));
+    return root;
+  } catch {
+    return null;
+  }
+}
+function loadEnvFile(projectDir) {
+  loadDotenv({ path: join2(projectDir, ".env") });
+}
+
+export {
+  ConnectionSchema,
+  ChartSchema,
+  ProjectSchema,
+  DashboardSchema,
+  ScheduleSchema,
+  validateProject,
+  findProjectRoot,
+  loadEnvFile
+};
+//# sourceMappingURL=chunk-A24KVXJQ.js.map