yamchart 0.8.7 → 0.9.0

package/dist/{dev-Z2R2DBWO.js → dev-6QGAB4ZH.js}

@@ -1,7 +1,7 @@
 import {
   loadEnvFile,
   validateProject
-} from "./chunk-GLCEDWGH.js";
+} from "./chunk-G57J2WQM.js";
 import {
   box,
   detail,
@@ -23,7 +23,11 @@ import {
   SemanticQuerySchema,
   deepMerge,
   resolveProjectConfig
-} from "./chunk-C7A7TKSY.js";
+} from "./chunk-E2QN2M7S.js";
+import {
+  StreamingChatAgent,
+  filterCatalogEntries
+} from "./chunk-ZA6AOQVZ.js";
 import {
   AuthDatabase,
   generateSessionToken,
@@ -53,7 +57,7 @@ import {
   resolveMySQLAuth,
   resolvePostgresAuth,
   resolveSnowflakeAuth
-} from "./chunk-5N3FYFBV.js";
+} from "./chunk-CWAWATL4.js";
 import {
   SemanticModelBuilder,
   SemanticQueryCompiler,
@@ -63,7 +67,7 @@ import {
 import "./chunk-DGUM43GV.js";
 
 // src/commands/dev.ts
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 import { homedir } from "os";
 
 // ../server/dist/server.js
@@ -76,6 +80,257 @@ import { readFile, readdir, access } from "fs/promises";
 import { join, extname, relative, dirname } from "path";
 import { parse as parseYaml } from "yaml";
 import { watch } from "chokidar";
+
+// ../../packages/chat/dist/registry.js
+import { parse } from "yaml";
+
+// ../../packages/chat/dist/agents/dashboard-analyst.js
+var DASHBOARD_ANALYST = {
+  name: "dashboard-analyst",
+  title: "Dashboard Analyst",
+  description: "Summarizes dashboards, explains trends, answers data questions, and can apply filters to the dashboard.",
+  systemPrompt: `You are an AI dashboard analyst for a business intelligence platform.
+
+Your job is to help users understand their data by:
+- Summarizing what a dashboard or chart shows
+- Explaining trends, outliers, and patterns in the data
+- Answering questions about metrics and KPIs
+- Suggesting and applying filters to explore data
+- Running ad-hoc SQL to explore data beyond existing charts
+
+## Rules
+- Be concise. Dashboard users want quick answers, not essays.
+- Use numbers and percentages when discussing data.
+- When you query data, summarize the key findings \u2014 don't dump raw rows.
+- If asked about a trend, explain the direction, magnitude, and possible causes.
+- When suggesting filters, explain what you expect to see.
+- Use the apply_filter tool when the user asks to filter or drill down.
+- If the existing charts don't have the data needed, use run_sql to query the database directly.
+- Use call_agent to delegate to specialized agents when you need expertise you don't have.
+- Use suggest_actions to offer follow-up exploration or save options after answering.
+- If you don't have enough data to answer, say so and suggest what to query.
+
+## Data Visualization in Responses
+When you have tabular data to share, use these markdown code fences:
+
+For charts (line, bar, pie, scatter):
+\`\`\`chart
+{"type":"line","data":[{"date":"2025-01-01","value":100},...],"x":"date","y":"value","title":"Optional Title"}
+\`\`\`
+
+For data tables:
+\`\`\`data
+{"columns":[{"name":"date","type":"date"},{"name":"value","type":"number"}],"rows":[{"date":"2025-01-01","value":100},...]}
+\`\`\`
+
+Choose charts for trends and comparisons, tables for detailed breakdowns. Keep data concise \u2014 summarize large result sets.`,
+  tools: ["query_model", "get_chart_config", "get_dashboard_summary", "apply_filter", "compare_periods", "run_sql", "call_agent", "get_catalog_tables", "suggest_actions", "save_model", "save_chart", "add_to_dashboard"],
+  builtIn: true
+};
+
+// ../../packages/chat/dist/agents/sql-explorer.js
+var SQL_EXPLORER = {
+  name: "sql-explorer",
+  title: "SQL Explorer",
+  description: "Runs ad-hoc SQL queries against the connected database for deep data exploration and period comparisons.",
+  systemPrompt: `You are a SQL expert helping users explore their data warehouse.
+
+Your job is to:
+- Write and execute SQL queries to answer user questions
+- Compare data across time periods
+- Find specific records or aggregations
+- Explain query results clearly
+
+## Rules
+- Always LIMIT your queries (default: 50 rows) to avoid large payloads.
+- Use clear column aliases so results are readable.
+- When comparing periods, use the compare_periods tool for models, or write explicit SQL for ad-hoc comparisons.
+- Explain what your query does before showing results.
+- If a query fails, explain the error and try a corrected version.
+- Never run destructive queries (INSERT, UPDATE, DELETE, DROP, etc.).
+
+## Data Visualization in Responses
+When you have tabular data to share, use these markdown code fences:
+
+For charts (line, bar, pie, scatter):
+\`\`\`chart
+{"type":"line","data":[{"date":"2025-01-01","value":100},...],"x":"date","y":"value","title":"Optional Title"}
+\`\`\`
+
+For data tables:
+\`\`\`data
+{"columns":[{"name":"date","type":"date"},{"name":"value","type":"number"}],"rows":[{"date":"2025-01-01","value":100},...]}
+\`\`\`
+
+Choose charts for trends and comparisons, tables for detailed breakdowns. Keep data concise \u2014 summarize large result sets.`,
+  tools: ["query_model", "run_sql", "compare_periods", "get_chart_config", "call_agent", "get_catalog_tables", "suggest_actions", "save_model", "save_chart"],
+  builtIn: true
+};
+
+// ../../packages/chat/dist/agents/data-explorer.js
+var DATA_EXPLORER = {
+  name: "data-explorer",
+  title: "Data Explorer",
+  description: "Open-ended data exploration, visualization, and dashboard building.",
+  systemPrompt: `You are an AI data explorer for a business intelligence platform.
+
+Your job is to help users explore their data warehouse, build visualizations, and create dashboards \u2014 starting from curiosity and ending with saved, reusable charts.
+
+## Discovery First
+- Always start with get_catalog_tables to understand what data is available before writing SQL.
+- Prefer querying named models (query_model) over raw SQL when a model already exists.
+- When no model exists, use run_sql to explore \u2014 then offer to save the query as a model.
+
+## Rules
+- All SQL must be read-only (SELECT only). Never run INSERT, UPDATE, DELETE, DROP, ALTER, TRUNCATE, or CREATE.
+- Always LIMIT queries to 50 rows by default. Use LIMIT explicitly.
+- Use clear column aliases so results are readable.
+- When a query fails, explain the error and try a corrected version.
+- Explain what you're querying and why before showing results.
+
+## Proactive Visualization
+After retrieving data, always visualize it \u2014 don't just dump raw rows. Choose the right form:
+- Trends over time \u2192 line chart
+- Comparisons across categories \u2192 bar chart
+- Part-to-whole \u2192 pie chart
+- Single key metric \u2192 show as bold text or KPI
+- Detailed breakdowns \u2192 data table
+
+For charts (line, bar, pie, scatter):
+\`\`\`chart
+{"type":"line","data":[{"date":"2025-01-01","value":100},...],"x":"date","y":"value","title":"Optional Title"}
+\`\`\`
+
+For data tables:
+\`\`\`data
+{"columns":[{"name":"date","type":"date"},{"name":"value","type":"number"}],"rows":[{"date":"2025-01-01","value":100},...]}
+\`\`\`
+
+Keep visualizations concise \u2014 summarize large result sets rather than showing every row.
+
+## Saving Work
+When a user wants to keep a query or chart:
+1. Use save_model to create a reusable SQL model file.
+2. Use save_chart to create a chart YAML referencing that model.
+3. Use create_dashboard to assemble saved charts into a new dashboard.
+4. After saving, use suggest_actions to offer navigation or further exploration.
+
+## Suggesting Next Steps
+Always use suggest_actions after answering a question to offer natural follow-up options:
+- Explore related dimensions or time periods
+- Save the current query as a model
+- Create a chart from the data
+- Add the chart to a dashboard
+
+## Collaboration
+Use call_agent to delegate to specialized agents when needed:
+- Dashboard Analyst for questions about existing dashboards
+- SQL Explorer for complex multi-step SQL investigations`,
+  tools: ["run_sql", "query_model", "get_catalog_tables", "compare_periods", "save_model", "save_chart", "create_dashboard", "suggest_actions", "call_agent"],
+  builtIn: true
+};
+
+// ../../packages/chat/dist/registry.js
+var AgentRegistry = class {
+  agents = /* @__PURE__ */ new Map();
+  constructor() {
+    this.agents.set(DASHBOARD_ANALYST.name, DASHBOARD_ANALYST);
+    this.agents.set(SQL_EXPLORER.name, SQL_EXPLORER);
+    this.agents.set(DATA_EXPLORER.name, DATA_EXPLORER);
+  }
+  getAgent(name) {
+    return this.agents.get(name);
+  }
+  listAgents() {
+    return Array.from(this.agents.values());
+  }
+  registerAgent(config) {
+    this.agents.set(config.name, config);
+  }
+  loadFromYaml(yamlContent, filePath, onWarning) {
+    try {
+      const raw = parse(yamlContent);
+      if (!raw || typeof raw !== "object") {
+        onWarning?.(`Skipping ${filePath}: not a valid YAML object`);
+        return;
+      }
+      if (!raw.name || typeof raw.name !== "string") {
+        onWarning?.(`Skipping ${filePath}: missing required "name" field`);
+        return;
+      }
+      if (!raw.description || typeof raw.description !== "string") {
+        onWarning?.(`Skipping ${filePath}: missing required "description" field`);
+        return;
+      }
+      if (!raw.system_prompt || typeof raw.system_prompt !== "string") {
+        onWarning?.(`Skipping ${filePath}: missing required "system_prompt" field`);
+        return;
+      }
+      const config = {
+        name: raw.name,
+        title: raw.title ?? raw.name,
+        description: raw.description,
+        systemPrompt: raw.system_prompt,
+        tools: Array.isArray(raw.tools) ? raw.tools.filter((t) => typeof t === "string") : [],
+        builtIn: false,
+        model: typeof raw.model === "string" ? raw.model : void 0,
+        models: Array.isArray(raw.models) ? raw.models.filter((m) => typeof m === "string") : void 0
+      };
+      this.agents.set(config.name, config);
+    } catch (err) {
+      onWarning?.(`Skipping ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  clearProjectAgents() {
+    for (const [name, config] of this.agents) {
+      if (!config.builtIn)
+        this.agents.delete(name);
+    }
+  }
+};
+
+// ../../packages/chat/dist/router.js
+var SQL_PATTERNS = [
+  /\bselect\b.*\bfrom\b/i,
+  /\brun\s+(a\s+)?query\b/i,
+  /\bwrite\s+(a\s+)?query\b/i,
+  /\bshow\s+(me\s+)?the\s+sql\b/i,
+  /\bexecute\s+sql\b/i,
+  /\bjoin\b.*\btable/i
+];
+var DEFAULT_AGENT = "dashboard-analyst";
+var RouterAgent = class {
+  registry;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  selectAgent(message, context, explicitAgent) {
+    if (explicitAgent) {
+      const agent = this.registry.getAgent(explicitAgent);
+      if (agent)
+        return agent;
+    }
+    if (context?.type === "explore") {
+      return this.registry.getAgent("data-explorer") || this.registry.getAgent(DEFAULT_AGENT);
+    }
+    if (SQL_PATTERNS.some((pattern) => pattern.test(message))) {
+      const sqlExplorer = this.registry.getAgent("sql-explorer");
+      if (sqlExplorer)
+        return sqlExplorer;
+    }
+    return this.registry.getAgent(DEFAULT_AGENT);
+  }
+};
+
+// ../../packages/chat/dist/stream.js
+function formatSSEEvent(event) {
+  return `event: ${event.type}
+data: ${JSON.stringify(event.data)}
+
+`;
+}
+
+// ../server/dist/services/config-loader.js
 var ConfigLoader = class {
   projectDir;
   project = null;
@@ -92,6 +347,7 @@ var ConfigLoader = class {
   validationErrors = /* @__PURE__ */ new Map();
   watcher = null;
   onChangeCallbacks = [];
+  agentRegistry = new AgentRegistry();
   env;
   constructor(projectDir, env) {
     this.projectDir = projectDir;
@@ -116,6 +372,7 @@ var ConfigLoader = class {
     await this.loadDashboards();
     await this.loadSchedules();
     await this.loadEvents();
+    await this.loadAgents();
   }
   async loadProject() {
     const projectPath = join(this.projectDir, "yamchart.yaml");
@@ -321,6 +578,20 @@ var ConfigLoader = class {
       console.warn(`Invalid events.yaml: ${result.error.message}`);
     }
   }
+  async loadAgents() {
+    const agentsDir = join(this.projectDir, "agents");
+    this.agentRegistry.clearProjectAgents();
+    try {
+      const files = await readdir(agentsDir);
+      for (const file of files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"))) {
+        const content = await readFile(join(agentsDir, file), "utf-8");
+        this.agentRegistry.loadFromYaml(content, `agents/${file}`, (msg) => {
+          console.warn(msg);
+        });
+      }
+    } catch {
+    }
+  }
   startWatching() {
     if (this.watcher)
       return;
@@ -332,7 +603,8 @@ var ConfigLoader = class {
       join(this.projectDir, "models"),
       join(this.projectDir, "dashboards"),
       join(this.projectDir, "schedules"),
-      join(this.projectDir, "events.yaml")
+      join(this.projectDir, "events.yaml"),
+      join(this.projectDir, "agents")
     ];
     this.watcher = watch(watchPaths, {
       ignored: /(^|[\/\\])\../,
@@ -453,6 +725,9 @@ Fix: run "ulimit -n 10240" before starting yamchart dev, or add it to your shell
   getValidationErrors() {
     return this.validationErrors;
   }
+  getAgentRegistry() {
+    return this.agentRegistry;
+  }
 };
 
 // ../server/dist/services/cache.js
@@ -529,12 +804,18 @@ function parseTtl2(ttl) {
 }
 
 // ../server/dist/services/query-service.js
+function quoteIdentifier(name, dialect) {
+  if (dialect === "mysql")
+    return `\`${name.replace(/`/g, "``")}\``;
+  return `"${name.replace(/"/g, '""')}"`;
+}
 var QueryService = class {
   compiler;
   connector;
   cache;
   models;
   refs;
+  dialect;
   constructor(config) {
     this.compiler = new QueryCompiler({
       models: config.models,
@@ -544,6 +825,7 @@ var QueryService = class {
     this.cache = config.cache;
     this.models = new Map(Object.entries(config.models));
     this.refs = config.refs;
+    this.dialect = config.dialect ?? "duckdb";
   }
   async executeChart(chart, params, userContext) {
     const compiled = this.compiler.compile(chart, params, userContext);
@@ -575,6 +857,120 @@ var QueryService = class {
       compiledSql: compiled.sql
     };
   }
+  /**
+   * Execute a table chart with server-side pagination.
+   * Wraps the compiled SQL with LIMIT/OFFSET and runs a parallel COUNT(*) query.
+   * Optionally computes summary aggregations for specified columns.
+   */
+  async executeChartPaginated(chart, params, options, userContext) {
+    const compiled = this.compiler.compile(chart, params, userContext);
+    const baseSql = compiled.sql;
+    const q = quoteIdentifier;
+    const d = this.dialect;
+    let orderBy = "";
+    if (options.sortField) {
+      const cleanField = options.sortField.replace(/[^\w\s]/g, "");
+      if (cleanField.length > 0) {
+        orderBy = `ORDER BY ${q(cleanField, d)} ${options.sortDirection === "desc" ? "DESC" : "ASC"}`;
+      }
+    }
+    const offset = options.page * options.pageSize;
+    const dataSql = `SELECT * FROM (${baseSql}) _t ${orderBy} LIMIT ${options.pageSize} OFFSET ${offset}`;
+    const countCacheKey = `${compiled.cacheKey}:count`;
+    let totalCount;
+    const cachedCount = await this.cache.get(countCacheKey);
+    if (cachedCount) {
+      totalCount = cachedCount.rowCount;
+    } else {
+      const countSql = `SELECT COUNT(*) AS _count FROM (${baseSql}) _t`;
+      const countResult = await this.connector.execute(countSql);
+      totalCount = Number(countResult.rows[0]?._count ?? 0);
+      await this.cache.set(countCacheKey, {
+        columns: [],
+        rows: [],
+        rowCount: totalCount,
+        durationMs: countResult.durationMs,
+        cachedAt: Date.now()
+      });
+    }
+    let summaryValues;
+    if (options.summaryColumns && options.summaryColumns.length > 0) {
+      const summaryCacheKey = `${compiled.cacheKey}:summary`;
+      const cachedSummary = await this.cache.get(summaryCacheKey);
+      if (cachedSummary && cachedSummary.rows[0]) {
+        summaryValues = cachedSummary.rows[0];
+      } else {
+        const aggExprs = options.summaryColumns.map(({ field, summary }) => {
+          const col = q(field, d);
+          switch (summary) {
+            case "sum":
+              return `SUM(${col}) AS ${q(`_sum_${field}`, d)}`;
+            case "avg":
+              return `AVG(${col}) AS ${q(`_avg_${field}`, d)}`;
+            case "min":
+              return `MIN(${col}) AS ${q(`_min_${field}`, d)}`;
+            case "max":
+              return `MAX(${col}) AS ${q(`_max_${field}`, d)}`;
+            case "count":
+              return `COUNT(${col}) AS ${q(`_count_${field}`, d)}`;
+            default:
+              return null;
+          }
+        }).filter(Boolean);
+        if (aggExprs.length > 0) {
+          const summarySql = `SELECT ${aggExprs.join(", ")} FROM (${baseSql}) _t`;
+          const summaryResult = await this.connector.execute(summarySql);
+          if (summaryResult.rows[0]) {
+            summaryValues = {};
+            for (const { field, summary } of options.summaryColumns) {
+              const key = `_${summary}_${field}`;
+              summaryValues[`${summary}:${field}`] = Number(summaryResult.rows[0][key] ?? 0);
+            }
+            await this.cache.set(summaryCacheKey, {
+              columns: [],
+              rows: [summaryValues],
+              rowCount: 0,
+              durationMs: summaryResult.durationMs,
+              cachedAt: Date.now()
+            });
+          }
+        }
+      }
+    }
+    const result = await this.connector.execute(dataSql);
+    return {
+      ...result,
+      cached: false,
+      cacheKey: compiled.cacheKey,
+      compiledSql: dataSql,
+      totalCount,
+      page: options.page,
+      pageSize: options.pageSize,
+      summaryValues
+    };
+  }
+  /**
+   * Execute a chart query for CSV export with a bounded row limit.
+   * Returns full QueryResult — caller streams to HTTP response.
+   */
+  async executeChartForExport(chart, params, maxRows, userContext) {
+    const compiled = this.compiler.compile(chart, params, userContext);
+    const sql = `SELECT * FROM (${compiled.sql}) _t LIMIT ${maxRows}`;
+    const result = await this.connector.execute(sql);
+    return {
+      ...result,
+      cached: false,
+      cacheKey: compiled.cacheKey,
+      compiledSql: sql
+    };
+  }
+  /**
+   * Compile a chart query without executing it.
+   * Returns the compiled SQL and cache key.
+   */
+  compileChart(chart, params, userContext) {
+    return this.compiler.compile(chart, params, userContext);
+  }
   invalidateChart(chartName) {
     this.cache.invalidatePattern(`${chartName}:*`);
   }
@@ -857,6 +1253,12 @@ function classifyError(error2) {
   }
   return "query_error";
 }
+function escapeCSVField(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
 function getUserContext(request) {
   const user = request.user;
   if (!user)
@@ -921,15 +1323,78 @@ async function chartRoutes(fastify, options) {
   });
   fastify.post("/api/charts/:name/query", async (request, reply) => {
     const { name } = request.params;
-    const params = request.body ?? {};
+    const rawParams = request.body ?? {};
     const includeConfig = request.query.includeConfig === "true";
     const chart = configLoader.getChartByName(name);
     if (!chart) {
       const resp = chartNotFoundResponse(configLoader, name);
       return reply.status(resp.status).send(resp.body);
     }
+    const { _page, _page_size, _sort_field, _sort_dir, _server_paginated, ...params } = rawParams;
     try {
-      const result = await queryService.executeChart(chart, params, getUserContext(request));
+      const isTable = chart.chart?.type === "table";
+      const project = configLoader.getProject();
+      const chartMaxRows = chart.chart?.max_rows;
+      const maxDisplayRows = chartMaxRows ?? project?.defaults?.table?.max_display_rows ?? 1e4;
+      const forceServerSide = chart.chart?.pagination && chart.chart.pagination?.server_side === true;
+      if (isTable && _server_paginated) {
+        const page = Number(_page) || 0;
+        const pageSize = Number(_page_size) || 50;
+        const columns = chart.chart?.columns ?? [];
+        const summaryColumns = columns.filter((c) => c.summary).map((c) => ({ field: c.field, summary: c.summary }));
+        const paginatedResult = await queryService.executeChartPaginated(chart, params, { page, pageSize, sortField: _sort_field, sortDirection: _sort_dir, summaryColumns }, getUserContext(request));
+        reply.header("X-Cache", "MISS");
+        reply.header("X-Query-Duration-Ms", paginatedResult.durationMs.toFixed(0));
+        const response2 = {
+          columns: paginatedResult.columns,
+          rows: paginatedResult.rows,
+          meta: {
+            cached: paginatedResult.cached,
+            durationMs: paginatedResult.durationMs,
+            rowCount: paginatedResult.rowCount,
+            cacheKey: paginatedResult.cacheKey,
+            compiledSql: paginatedResult.compiledSql,
+            serverPaginated: true,
+            totalCount: paginatedResult.totalCount,
+            page,
+            pageSize
+          },
+          ...paginatedResult.summaryValues ? { summaryValues: paginatedResult.summaryValues } : {}
+        };
+        if (includeConfig) {
+          response2.config = {
+            name: chart.name,
+            title: chart.title,
+            description: chart.description,
+            parameters: chart.parameters ?? [],
+            chart: chart.chart,
+            drillDown: chart.drillDown
+          };
+        }
+        return response2;
+      }
+      let result;
+      let serverPaginated = false;
+      let totalCount;
+      if (isTable) {
+        const probeResult = await queryService.executeChartForExport(chart, params, maxDisplayRows + 1, getUserContext(request));
+        if (probeResult.rowCount > maxDisplayRows || forceServerSide) {
+          serverPaginated = true;
+          if (probeResult.rowCount > maxDisplayRows) {
+            const compiled = queryService.compileChart(chart, params, getUserContext(request));
+            const countResult = await queryService.executeRawSql(`SELECT COUNT(*) AS _count FROM (${compiled.sql}) _t`);
+            totalCount = Number(countResult.rows[0]?._count ?? 0);
+            result = { ...probeResult, rows: probeResult.rows.slice(0, maxDisplayRows), rowCount: maxDisplayRows };
+          } else {
+            totalCount = probeResult.rowCount;
+            result = probeResult;
+          }
+        } else {
+          result = probeResult;
+        }
+      } else {
+        result = await queryService.executeChart(chart, params, getUserContext(request));
+      }
       let comparison = void 0;
       if (chart.chart?.type === "kpi" && chart.chart?.comparison?.period === "previous") {
         let startDate = params.start_date;
@@ -972,6 +1437,54 @@ async function chartRoutes(fastify, options) {
           }
         }
       }
+      const compareConfig = chart.chart?.compare;
+      let compareData;
+      if (compareConfig && compareConfig.length > 0) {
+        let startDate = params.start_date;
+        let endDate = params.end_date;
+        const dateRange = params.date_range;
+        if (!startDate || !endDate) {
+          if (isRelativeDateRange(params.date_range)) {
+            const resolved = expandRelativeDateRange(params.date_range);
+            startDate = resolved.start_date;
+            endDate = resolved.end_date;
+          } else if (isCustomDateRange(params.date_range)) {
+            const resolved = expandCustomDateRange(params.date_range);
+            startDate = resolved.start_date;
+            endDate = resolved.end_date;
+          } else if (dateRange && isDatePreset(dateRange)) {
+            const resolved = expandDatePreset(dateRange);
+            if (resolved) {
+              startDate = resolved.start_date;
+              endDate = resolved.end_date;
+            }
+          }
+        }
+        if (startDate && endDate) {
+          compareData = [];
+          for (const comp of compareConfig) {
+            try {
+              const periodMap = {
+                previous_week: "last_7_days",
+                previous_month: "last_30_days",
+                previous_quarter: "last_90_days",
+                previous_year: "last_365_days"
+              };
+              const prev = computePreviousPeriod(startDate, endDate, periodMap[comp.period] ?? comp.period);
+              const prevLabel = comp.label ?? comp.period.replace(/_/g, " ");
+              const { date_range: _, ...restParams } = params;
+              const prevParams = { ...restParams, start_date: prev.start_date, end_date: prev.end_date };
+              const prevResult = await queryService.executeChart(chart, prevParams, getUserContext(request));
+              compareData.push({
+                period: comp.period,
+                label: prevLabel,
+                rows: prevResult.rows
+              });
+            } catch {
+            }
+          }
+        }
+      }
       reply.header("X-Cache", result.cached ? "HIT" : "MISS");
       reply.header("X-Query-Duration-Ms", result.durationMs.toFixed(0));
       const meta = {
@@ -979,7 +1492,8 @@ async function chartRoutes(fastify, options) {
         durationMs: result.durationMs,
         rowCount: result.rowCount,
         cacheKey: result.cacheKey,
-        compiledSql: result.compiledSql
+        compiledSql: result.compiledSql,
+        ...serverPaginated ? { serverPaginated: true, totalCount } : {}
       };
       const response = {
         columns: result.columns,
@@ -999,6 +1513,9 @@ async function chartRoutes(fastify, options) {
       if (comparison) {
         response.comparison = comparison;
       }
+      if (compareData && compareData.length > 0) {
+        response.compareData = compareData;
+      }
       let goalData = void 0;
       const goals = chart.chart?.goals;
       const modelGoal = goals?.find((g) => g.type === "model" && g.source?.model);
@@ -1056,6 +1573,38 @@ async function chartRoutes(fastify, options) {
       return reply.status(500).send({ error: message, errorType: classifyError(error2) });
     }
   });
+  fastify.get("/api/charts/:name/export", async (request, reply) => {
+    const { name } = request.params;
+    const params = { ...request.query };
+    const chart = configLoader.getChartByName(name);
+    if (!chart) {
+      const resp = chartNotFoundResponse(configLoader, name);
+      return reply.status(resp.status).send(resp.body);
+    }
+    const project = configLoader.getProject();
+    const chartExportConfig = chart.chart?.export;
+    if (chartExportConfig?.enabled === false) {
+      return reply.status(403).send({ error: "Export is disabled for this chart", errorType: "validation_error" });
+    }
+    const maxExportRows = chartExportConfig?.max_rows ?? project?.defaults?.table?.max_export_rows ?? 5e5;
+    try {
+      const result = await queryService.executeChartForExport(chart, params, maxExportRows, getUserContext(request));
+      reply.header("Content-Type", "text/csv; charset=utf-8");
+      reply.header("Content-Disposition", `attachment; filename="${name}.csv"`);
+      reply.header("X-Total-Rows", String(result.rowCount));
+      const columns = result.columns.map((c) => c.name);
+      const headerLine = columns.map(escapeCSVField).join(",");
+      const lines = [headerLine];
+      for (const row of result.rows) {
+        const line = columns.map((col) => escapeCSVField(String(row[col] ?? ""))).join(",");
+        lines.push(line);
+      }
+      return reply.send(lines.join("\n"));
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : "Export failed";
+      return reply.status(500).send({ error: message, errorType: classifyError(error2) });
+    }
+  });
   fastify.post("/api/charts/batch", async (request, reply) => {
     const { charts, includeConfig } = request.body;
     if (!charts || !Array.isArray(charts)) {
@@ -1485,8 +2034,8 @@ async function semanticRoutes(fastify, options) {
       });
     }
     const { writeFileSync, mkdirSync } = await import("fs");
-    const { join: join7, dirname: dirname3 } = await import("path");
-    const fullPath = join7(projectDir, filePath);
+    const { join: join9, dirname: dirname3 } = await import("path");
+    const fullPath = join9(projectDir, filePath);
     mkdirSync(dirname3(fullPath), { recursive: true });
     writeFileSync(fullPath, sql, "utf-8");
     return { saved: true, path: filePath };
@@ -1599,7 +2148,7 @@ var SlackNotifier = class {
     let response = await fetch(webhookUrl, options);
     if (!response.ok) {
       if (this.retryDelayMs > 0) {
-        await new Promise((resolve2) => setTimeout(resolve2, this.retryDelayMs));
+        await new Promise((resolve3) => setTimeout(resolve3, this.retryDelayMs));
       }
       response = await fetch(webhookUrl, options);
       if (!response.ok) {
@@ -1858,11 +2407,11 @@ function __rest(s, e) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve2) {
-      resolve2(value);
+    return value instanceof P ? value : new P(function(resolve3) {
+      resolve3(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve2, reject) {
+  return new (P || (P = Promise))(function(resolve3, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -1878,7 +2427,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve3(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -4409,15 +4958,15 @@ var RealtimeChannel = class _RealtimeChannel {
         }
       }
     } else {
-      return new Promise((resolve2) => {
+      return new Promise((resolve3) => {
         var _a2, _b2, _c;
         const push = this._push(args.type, args, opts.timeout || this.timeout);
         if (args.type === "broadcast" && !((_c = (_b2 = (_a2 = this.params) === null || _a2 === void 0 ? void 0 : _a2.config) === null || _b2 === void 0 ? void 0 : _b2.broadcast) === null || _c === void 0 ? void 0 : _c.ack)) {
-          resolve2("ok");
+          resolve3("ok");
         }
-        push.receive("ok", () => resolve2("ok"));
-        push.receive("error", () => resolve2("error"));
-        push.receive("timeout", () => resolve2("timed out"));
+        push.receive("ok", () => resolve3("ok"));
+        push.receive("error", () => resolve3("error"));
+        push.receive("timeout", () => resolve3("timed out"));
       });
     }
   }
@@ -4445,16 +4994,16 @@ var RealtimeChannel = class _RealtimeChannel {
     };
     this.joinPush.destroy();
     let leavePush = null;
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       leavePush = new Push(this, CHANNEL_EVENTS.leave, {}, timeout);
       leavePush.receive("ok", () => {
         onClose();
-        resolve2("ok");
+        resolve3("ok");
       }).receive("timeout", () => {
         onClose();
-        resolve2("timed out");
+        resolve3("timed out");
       }).receive("error", () => {
-        resolve2("error");
+        resolve3("error");
       });
       leavePush.send();
       if (!this._canPush()) {
@@ -4533,8 +5082,8 @@ var RealtimeChannel = class _RealtimeChannel {
   _trigger(type, payload, ref) {
     var _a, _b;
     const typeLower = type.toLocaleLowerCase();
-    const { close, error: error2, leave, join: join7 } = CHANNEL_EVENTS;
-    const events = [close, error2, leave, join7];
+    const { close, error: error2, leave, join: join9 } = CHANNEL_EVENTS;
+    const events = [close, error2, leave, join9];
     if (ref && events.indexOf(typeLower) >= 0 && ref !== this._joinRef()) {
       return;
     }
@@ -6150,7 +6699,7 @@ var _getRequestParams = (method, options, parameters, body) => {
   return _objectSpread2(_objectSpread2({}, params), parameters);
 };
 async function _handleRequest(fetcher, method, url, options, parameters, body, namespace) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     fetcher(url, _getRequestParams(method, options, parameters, body)).then((result) => {
       if (!result.ok) throw result;
       if (options === null || options === void 0 ? void 0 : options.noResolveJson) return result;
@@ -6160,7 +6709,7 @@ async function _handleRequest(fetcher, method, url, options, parameters, body, n
         if (!contentType || !contentType.includes("application/json")) return {};
       }
       return result.json();
-    }).then((data) => resolve2(data)).catch((error2) => handleError(error2, reject, options, namespace));
+    }).then((data) => resolve3(data)).catch((error2) => handleError(error2, reject, options, namespace));
   });
 }
 function createFetchApi(namespace = "storage") {
@@ -13914,6 +14463,12 @@ async function publicRoutes(fastify, options) {
 }
 
 // ../server/dist/routes/chat.js
+import { resolve, join as join6 } from "path";
+import { readFile as readFile3 } from "fs/promises";
+function isChatEnabled(configLoader) {
+  const project = configLoader.getProject();
+  return !!(project?.features?.chat && process.env.ANTHROPIC_API_KEY);
+}
 async function chatRoutes(fastify, options) {
   const { configLoader, queryService } = options;
   fastify.post("/api/chat/generate-text", async (request, reply) => {
@@ -14036,7 +14591,7 @@ async function chatRoutes(fastify, options) {
         systemParts.push("Output ONLY the new text to insert. Do NOT repeat the existing content.");
       }
       const systemPrompt = systemParts.join("\n");
-      const { AnthropicProvider } = await import("./dist-GVNWQXFR.js");
+      const { AnthropicProvider } = await import("./dist-7CRX2GIR.js");
       const provider = new AnthropicProvider(apiKey);
       const response = await provider.chat({
         system: systemPrompt,
@@ -14052,6 +14607,210 @@ async function chatRoutes(fastify, options) {
       return reply.status(500).send({ error: message });
     }
   });
+  fastify.get("/api/chat/agents", async (request, reply) => {
+    if (!isChatEnabled(configLoader)) {
+      return reply.code(404).send({ error: "Chat not enabled" });
+    }
+    const registry = configLoader.getAgentRegistry();
+    const agents = registry.listAgents().map((a) => ({
+      name: a.name,
+      title: a.title,
+      description: a.description,
+      builtIn: a.builtIn
+    }));
+    return agents;
+  });
+  fastify.post("/api/chat/stream", async (request, reply) => {
+    if (!isChatEnabled(configLoader)) {
+      return reply.code(404).send({ error: "Chat not enabled" });
+    }
+    const body = request.body;
+    if (!body.message) {
+      return reply.code(400).send({ error: "message is required" });
+    }
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    const registry = configLoader.getAgentRegistry();
+    const router = new RouterAgent(registry);
+    const chatContext = body.context ?? { type: "general" };
+    const agentConfig = router.selectAgent(body.message, chatContext, body.agent);
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    const emitEvent = (event) => {
+      reply.raw.write(formatSSEEvent(event));
+    };
+    emitEvent({ type: "agent_selected", data: { name: agentConfig.name, title: agentConfig.title } });
+    const project = configLoader.getProject();
+    const toolContext = {
+      configLoader: {
+        getChartByName: (name) => configLoader.getChartByName(name),
+        getDashboardByName: (name) => configLoader.getDashboardByName(name),
+        getDashboards: () => configLoader.getDashboards(),
+        getCharts: () => configLoader.getCharts(),
+        getModels: () => configLoader.getModels?.() ?? [],
+        getProject: () => configLoader.getProject(),
+        load: () => configLoader.load()
+      },
+      queryService: {
+        executeChart: (chart, params, userCtx) => queryService.executeChart(chart, params, userCtx),
+        executeRawSql: (sql) => queryService.executeRawSql(sql)
+      },
+      projectDir: options.projectDir,
+      catalogPath: resolve(options.projectDir, ".yamchart", "catalog.json"),
+      agentRegistry: configLoader.getAgentRegistry(),
+      userContext: request.user ? { id: request.user.id, email: request.user.email, role: request.user.role } : void 0,
+      emitEvent,
+      chatContext,
+      catalogFilter: project?.catalog?.include
+    };
+    let systemPrompt = agentConfig.systemPrompt;
+    if (chatContext.type === "dashboard" && chatContext.name) {
+      const dashboard = configLoader.getDashboardByName(chatContext.name);
+      if (dashboard) {
+        const chartRefs = [];
+        const extractRefs = (layout) => {
+          for (const row of layout.rows ?? []) {
+            for (const widget of row.widgets ?? []) {
+              if (widget.type === "chart" && widget.ref)
+                chartRefs.push(widget.ref);
+            }
+          }
+        };
+        if (dashboard.layout)
+          extractRefs(dashboard.layout);
+        if (dashboard.tabs) {
+          for (const tab of dashboard.tabs) {
+            if (tab.layout)
+              extractRefs(tab.layout);
+          }
+        }
+        const chartDetails = [];
+        for (const ref of chartRefs) {
+          const chart = configLoader.getChartByName(ref);
+          if (!chart)
+            continue;
+          const model = chart.source?.model ? `, model: "${chart.source.model}"` : "";
+          const params = chart.parameters?.length ? `, params: [${chart.parameters.map((p) => `${p.name}(${p.type})`).join(", ")}]` : "";
+          chartDetails.push(`  - "${ref}" (${chart.chart?.type ?? "unknown"}${model}${params}): ${chart.title ?? ref}`);
+        }
+        const filters = dashboard.filters?.length ? `
+Dashboard filters: ${dashboard.filters.map((f) => `${f.name}(${f.type}, default: ${f.default ?? "none"})`).join(", ")}` : "";
+        systemPrompt += `
+
+The user is viewing the "${dashboard.title ?? dashboard.name}" dashboard (id: "${dashboard.name}").${filters}
+Charts on this dashboard:
+${chartDetails.join("\n")}
+
+IMPORTANT: When using query_model, pass the chart name (e.g. "${chartRefs[0] ?? "chart-name"}") \u2014 NOT the model name. The chart name is what appears before the parentheses above.`;
+      }
+    } else if (chatContext.type === "chart" && chatContext.name) {
+      const chart = configLoader.getChartByName(chatContext.name);
+      if (chart) {
+        const model = chart.source?.model ? ` Model: "${chart.source.model}".` : "";
+        const params = chart.parameters?.length ? ` Parameters: ${chart.parameters.map((p) => `${p.name}(${p.type})`).join(", ")}.` : "";
+        systemPrompt += `
+
+The user is viewing the "${chart.title ?? chart.name}" chart (id: "${chart.name}", type: ${chart.chart?.type}).${model}${params}`;
+      }
+    } else if (chatContext.type === "explore") {
+      const catalogPath = join6(options.projectDir, ".yamchart", "catalog.json");
+      const tableLines = [];
+      try {
+        const catalogData = JSON.parse(await readFile3(catalogPath, "utf-8"));
+        const filteredModels = filterCatalogEntries(catalogData.models ?? [], project?.catalog?.include);
+        for (const entry of filteredModels) {
+          const fullName = entry.table ?? entry.name;
+          const cols = (entry.columns ?? []).map((c) => c.name).join(", ");
+          const colSuffix = cols ? ` (${entry.columns?.length} columns: ${cols})` : "";
+          tableLines.push(`- ${fullName}${colSuffix}`);
+        }
+      } catch {
+      }
+      const configModels = configLoader.getModels?.() ?? [];
+      const modelLines = configModels.map((m) => m.metadata.description ? `- ${m.metadata.name}: ${m.metadata.description}` : `- ${m.metadata.name}`);
+      if (tableLines.length === 0 && modelLines.length === 0) {
+        systemPrompt += "\n\nNo catalog data available. Use get_catalog_tables or run_sql to discover tables.";
+      } else {
+        const parts = ["\n"];
+        if (tableLines.length > 0) {
+          parts.push("## Available Tables", ...tableLines);
+        }
+        if (modelLines.length > 0) {
+          if (parts.length > 1)
+            parts.push("");
+          parts.push("## Available Models", ...modelLines);
+        }
+        systemPrompt += parts.join("\n");
+      }
+    }
+    const messages = [];
+    for (const msg of body.history ?? []) {
+      messages.push({ role: msg.role, content: msg.content });
+    }
+    messages.push({ role: "user", content: body.message });
+    try {
+      const agent = new StreamingChatAgent(agentConfig, apiKey);
+      await agent.run(systemPrompt, messages, toolContext, emitEvent);
+    } catch (err) {
+      emitEvent({
+        type: "error",
+        data: { message: err instanceof Error ? err.message : "Stream failed" }
+      });
+    }
+    reply.raw.end();
+  });
+}
+
+// ../server/dist/routes/catalog.js
+import { join as join7 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+async function catalogRoutes(fastify, options) {
+  const { configLoader, projectDir } = options;
+  fastify.get("/api/catalog/summary", async (_request2, reply) => {
+    const connections = configLoader.getConnections().map((c) => ({
+      name: c.name,
+      type: c.type
+    }));
+    const configModels = configLoader.getModels().map((m) => ({
+      name: m.metadata.name,
+      description: m.metadata.description
+    }));
+    const catalogPath = join7(projectDir, ".yamchart", "catalog.json");
+    let tables = [];
+    try {
+      const catalogData = JSON.parse(await readFile4(catalogPath, "utf-8"));
+      const allCatalogModels = catalogData.models ?? [];
+      const project = configLoader.getProject();
+      const catalogModels = filterCatalogEntries(allCatalogModels, project?.catalog?.include);
+      tables = catalogModels.map((m) => {
+        const fullName = m.table ?? m.name ?? "";
+        const parts = fullName.split(".");
+        const tableName = parts[parts.length - 1] ?? fullName;
+        const schema = parts.length > 1 ? parts.slice(0, -1).join(".") : void 0;
+        const columns = (m.columns ?? []).map((c) => ({
+          name: c.name,
+          type: c.data_type
+        }));
+        return {
+          name: tableName,
+          ...schema ? { schema } : {},
+          connection: m.connection ?? (connections[0]?.name ?? "default"),
+          columnCount: columns.length,
+          columns
+        };
+      });
+    } catch {
+    }
+    return reply.send({
+      connections,
+      tables,
+      models: configModels,
+      tableCount: tables.length,
+      modelCount: configModels.length
+    });
+  });
 }
 
 // ../server/dist/routes/events.js
@@ -14093,18 +14852,18 @@ data: ${data}
 }
 
 // ../server/dist/server.js
-import { join as join6, dirname as dirname2 } from "path";
+import { join as join8, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
-import { access as access2, readFile as readFile3 } from "fs/promises";
+import { access as access2, readFile as readFile5 } from "fs/promises";
 import { watch as fsWatch } from "fs";
 var __dirname = dirname2(fileURLToPath(import.meta.url));
-var packageJsonPath = join6(__dirname, "..", "package.json");
-var packageJson = JSON.parse(await readFile3(packageJsonPath, "utf-8"));
+var packageJsonPath = join8(__dirname, "..", "package.json");
+var packageJson = JSON.parse(await readFile5(packageJsonPath, "utf-8"));
 var VERSION = packageJson.version;
 async function enrichRefsFromCatalog(projectDir, refs) {
   try {
-    const catalogPath = join6(projectDir, ".yamchart", "catalog.json");
-    const catalogData = JSON.parse(await readFile3(catalogPath, "utf-8"));
+    const catalogPath = join8(projectDir, ".yamchart", "catalog.json");
+    const catalogData = JSON.parse(await readFile5(catalogPath, "utf-8"));
     for (const model of catalogData.models ?? []) {
       if (model.name && model.table) {
         refs[model.name] = model.table;
@@ -14114,7 +14873,7 @@ async function enrichRefsFromCatalog(projectDir, refs) {
   }
 }
 async function createServer(options) {
-  const { projectDir, port = 3001, host = "0.0.0.0", watch: watch2 = false, serveStatic = process.env.NODE_ENV === "production", staticDir = join6(__dirname, "public"), auth } = options;
+  const { projectDir, port = 3001, host = "0.0.0.0", watch: watch2 = false, serveStatic = process.env.NODE_ENV === "production", staticDir = join8(__dirname, "public"), auth } = options;
   if (auth) {
     initAuthServer(auth.supabaseUrl, auth.supabaseServiceKey);
   }
@@ -14168,7 +14927,8 @@ async function createServer(options) {
     connector,
     cache,
     models,
-    refs
+    refs,
+    dialect: defaultConnection.type
   });
   const semanticService = new SemanticService({
     projectDir,
@@ -14248,6 +15008,7 @@ async function createServer(options) {
       await protectedRoutes.register(chartEventsRoutes, { configLoader, projectDir });
       await protectedRoutes.register(dashboardRoutes, { configLoader, gitService, projectDir, queryService });
       await protectedRoutes.register(chatRoutes, { configLoader, queryService, projectDir });
+      await protectedRoutes.register(catalogRoutes, { configLoader, projectDir });
     });
   } else if (authDb) {
     const localMiddleware = createLocalAuthMiddleware(authDb);
@@ -14258,6 +15019,7 @@ async function createServer(options) {
       await protectedRoutes.register(chartEventsRoutes, { configLoader, projectDir });
       await protectedRoutes.register(dashboardRoutes, { configLoader, gitService, projectDir, queryService });
       await protectedRoutes.register(chatRoutes, { configLoader, queryService, projectDir });
+      await protectedRoutes.register(catalogRoutes, { configLoader, projectDir });
       await protectedRoutes.register(sharesRoutes, { authDb });
     });
   } else {
@@ -14266,8 +15028,9 @@ async function createServer(options) {
     await fastify.register(chartEventsRoutes, { configLoader, projectDir });
     await fastify.register(dashboardRoutes, { configLoader, gitService, projectDir, queryService });
     await fastify.register(chatRoutes, { configLoader, queryService, projectDir });
+    await fastify.register(catalogRoutes, { configLoader, projectDir });
   }
-  const assetsDir = join6(projectDir, "assets");
+  const assetsDir = join8(projectDir, "assets");
   try {
     await access2(assetsDir);
     await fastify.register(fastifyStatic, {
@@ -14278,10 +15041,10 @@ async function createServer(options) {
   } catch {
   }
   if (project.theme?.customCss) {
-    const cssPath = join6(projectDir, project.theme.customCss);
+    const cssPath = join8(projectDir, project.theme.customCss);
     fastify.get("/api/theme/custom.css", async (_request2, reply) => {
       try {
-        const content = await readFile3(cssPath, "utf-8");
+        const content = await readFile5(cssPath, "utf-8");
         return reply.type("text/css").send(content);
       } catch {
         return reply.status(404).send("");
@@ -14337,7 +15100,7 @@ async function createServer(options) {
       fastify.log.info(`Semantic model rebuilt: ${semanticService.getModel()?.entities.length ?? 0} entities`);
       broadcastConfigChange();
     });
-    const catalogPath = join6(projectDir, ".yamchart", "catalog.json");
+    const catalogPath = join8(projectDir, ".yamchart", "catalog.json");
     try {
       catalogWatcher = fsWatch(catalogPath, () => {
         semanticService.buildFromDisk();
@@ -14402,15 +15165,15 @@ async function runDevServer(projectDir, options) {
   let localAuth;
   try {
     const { readFileSync: readFileSync2 } = await import("fs");
-    const { parse } = await import("yaml");
-    const { resolveProjectConfig: resolveProjectConfig2, deepMerge: deepMerge3 } = await import("./dist-LJR7TAW4.js");
-    const raw = readFileSync2(resolve(projectDir, "yamchart.yaml"), "utf-8");
-    const rawConfig = parse(raw);
+    const { parse: parse2 } = await import("yaml");
+    const { resolveProjectConfig: resolveProjectConfig2, deepMerge: deepMerge3 } = await import("./dist-4GUE24QV.js");
+    const raw = readFileSync2(resolve2(projectDir, "yamchart.yaml"), "utf-8");
+    const rawConfig = parse2(raw);
     const resolvedEnv = options.env || process.env.YAMCHART_ENV || void 0;
     let projectConfig = resolveProjectConfig2(rawConfig, resolvedEnv);
     try {
-      const localRaw = readFileSync2(resolve(projectDir, "yamchart.local.yaml"), "utf-8");
-      const localOverrides = parse(localRaw);
+      const localRaw = readFileSync2(resolve2(projectDir, "yamchart.local.yaml"), "utf-8");
+      const localOverrides = parse2(localRaw);
       if (localOverrides && typeof localOverrides === "object") {
         projectConfig = deepMerge3(projectConfig, localOverrides);
       }
@@ -14419,16 +15182,16 @@ async function runDevServer(projectDir, options) {
     if (projectConfig?.auth?.enabled) {
       localAuth = {
         enabled: true,
-        dbPath: projectConfig.auth.db_path ? resolve(projectConfig.auth.db_path.replace(/^~/, homedir())) : resolve(homedir(), ".yamchart", "auth.db"),
+        dbPath: projectConfig.auth.db_path ? resolve2(projectConfig.auth.db_path.replace(/^~/, homedir())) : resolve2(homedir(), ".yamchart", "auth.db"),
         sessionTtlMs: projectConfig.auth.session_ttl ? parseTtl(projectConfig.auth.session_ttl) : 30 * 24 * 60 * 60 * 1e3
       };
     }
-    const connectionDir = resolve(projectDir, "connections");
+    const connectionDir = resolve2(projectDir, "connections");
     const targetConn = process.env.YAMCHART_CONNECTION || projectConfig?.defaults?.connection;
     if (targetConn) {
       try {
-        const connRaw = readFileSync2(resolve(connectionDir, `${targetConn}.yaml`), "utf-8");
-        const connConfig = parse(connRaw);
+        const connRaw = readFileSync2(resolve2(connectionDir, `${targetConn}.yaml`), "utf-8");
+        const connConfig = parse2(connRaw);
         if (connConfig?.auth?.type === "externalbrowser") {
           usesBrowserAuth = true;
         }
@@ -14443,21 +15206,33 @@ async function runDevServer(projectDir, options) {
   }
   const spinner2 = spinner("Starting server...");
   let server;
-  try {
-    server = await createServer({
-      projectDir,
-      port: options.port,
-      watch: true,
-      serveStatic: !options.apiOnly,
-      localAuth,
-      env: options.env
-    });
-    await server.start();
-    spinner2.stop();
-  } catch (err) {
-    spinner2.fail("Failed to start server");
-    error(err instanceof Error ? err.message : "Unknown error");
-    process.exit(1);
+  let actualPort = options.port;
+  const MAX_PORT_ATTEMPTS = 10;
+  for (let attempt = 0; attempt < MAX_PORT_ATTEMPTS; attempt++) {
+    try {
+      server = await createServer({
+        projectDir,
+        port: actualPort,
+        watch: true,
+        serveStatic: !options.apiOnly,
+        localAuth,
+        env: options.env
+      });
+      await server.start();
+      spinner2.stop();
+      if (actualPort !== options.port) {
+        info(`Port ${options.port} is in use, starting on port ${actualPort}`);
+      }
+      break;
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err && err.code === "EADDRINUSE" && attempt < MAX_PORT_ATTEMPTS - 1) {
+        actualPort++;
+        continue;
+      }
+      spinner2.fail("Failed to start server");
+      error(err instanceof Error ? err.message : "Unknown error");
+      process.exit(1);
+    }
   }
   const project = server.configLoader.getProject();
   const charts = server.configLoader.getCharts();
@@ -14466,8 +15241,8 @@ async function runDevServer(projectDir, options) {
   box([
     `Yamchart v${options.version}`,
     ``,
-    `Dashboard:  http://localhost:${options.port}`,
-    `API:        http://localhost:${options.port}/api`,
+    `Dashboard:  http://localhost:${actualPort}`,
+    `API:        http://localhost:${actualPort}/api`,
     ``,
     `Project:    ${project.name}`,
     `Charts:     ${charts.length} loaded`,
@@ -14478,7 +15253,7 @@ async function runDevServer(projectDir, options) {
   ]);
   newline();
   if (options.open && !options.apiOnly) {
-    const url = `http://localhost:${options.port}`;
+    const url = `http://localhost:${actualPort}`;
     const { exec } = await import("child_process");
     const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
     exec(`${command} ${url}`);
@@ -14495,4 +15270,4 @@ async function runDevServer(projectDir, options) {
 export {
   runDevServer
 };
-//# sourceMappingURL=dev-Z2R2DBWO.js.map
+//# sourceMappingURL=dev-6QGAB4ZH.js.map