squads-cli 0.6.2 → 0.7.0

package/dist/dashboard-MFNRLCEE.js

@@ -0,0 +1,794 @@
+#!/usr/bin/env node
+import {
+  RESET,
+  barChart,
+  bold,
+  box,
+  colors,
+  gradient,
+  padEnd,
+  progressBar,
+  sparkline,
+  truncate,
+  writeLine
+} from "./chunk-N7KDWU4W.js";
+import "./chunk-7OCVIDC7.js";
+
+// src/lib/dashboard/loader.ts
+import { readFileSync, readdirSync, existsSync } from "fs";
+import { join, basename } from "path";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var yaml = require2("js-yaml");
+var dashboardCache = /* @__PURE__ */ new Map();
+function findDashboardsDir() {
+  let dir = process.cwd();
+  for (let i = 0; i < 10; i++) {
+    const dashDir = join(dir, ".agents", "dashboards");
+    if (existsSync(dashDir)) {
+      return dashDir;
+    }
+    const parent = join(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function listDashboards() {
+  const dir = findDashboardsDir();
+  if (!dir) return [];
+  try {
+    return readdirSync(dir).filter((f) => f.endsWith(".yaml") && !f.startsWith("_")).map((f) => basename(f, ".yaml"));
+  } catch {
+    return [];
+  }
+}
+function loadDashboard(name) {
+  if (dashboardCache.has(name)) {
+    return dashboardCache.get(name);
+  }
+  const dir = findDashboardsDir();
+  if (!dir) return null;
+  const filePath = join(dir, `${name}.yaml`);
+  if (!existsSync(filePath)) return null;
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const def = yaml.load(content);
+    if (!def.name || !def.title || !def.source || !def.metrics || !def.views) {
+      console.error(`Invalid dashboard definition: ${name}`);
+      return null;
+    }
+    dashboardCache.set(name, def);
+    return def;
+  } catch (err) {
+    console.error(`Error loading dashboard ${name}:`, err);
+    return null;
+  }
+}
+function loadAllDashboards() {
+  const names = listDashboards();
+  return names.map((name) => loadDashboard(name)).filter((d) => d !== null);
+}
+function clearDashboardCache() {
+  dashboardCache.clear();
+}
+function findDashboard(query) {
+  const exact = loadDashboard(query);
+  if (exact) return exact;
+  const all = listDashboards();
+  const match = all.find(
+    (name) => name.toLowerCase().includes(query.toLowerCase())
+  );
+  if (match) return loadDashboard(match);
+  return null;
+}
+
+// src/lib/dashboard/sources/postgres.ts
+var postgresSource = {
+  name: "postgres",
+  async query(_sql, _params = []) {
+    return { rows: [], columns: [] };
+  },
+  async isAvailable() {
+    return false;
+  },
+  async close() {
+  }
+};
+function buildQuery(table, metrics, groupBy, where, orderBy, limit) {
+  const selectParts = [];
+  if (groupBy && groupBy.length > 0) {
+    for (const col of groupBy) {
+      selectParts.push(col);
+    }
+  }
+  for (const metric of metrics) {
+    selectParts.push(`${metric.sql} AS ${metric.name}`);
+  }
+  let sql = `SELECT ${selectParts.join(", ")} FROM ${table}`;
+  if (where) {
+    sql += ` WHERE ${where}`;
+  }
+  if (groupBy && groupBy.length > 0) {
+    sql += ` GROUP BY ${groupBy.join(", ")}`;
+  }
+  if (orderBy) {
+    sql += ` ORDER BY ${orderBy}`;
+  }
+  if (limit) {
+    sql += ` LIMIT ${limit}`;
+  }
+  return sql;
+}
+function buildWhereClause(filters, filterDefs) {
+  const conditions = [];
+  for (const [name, value] of Object.entries(filters)) {
+    if (value === void 0 || value === null) continue;
+    const def = filterDefs.find((f) => f.name === name);
+    if (!def) continue;
+    const field = def.field || name;
+    if (def.type === "date_range" && typeof value === "object") {
+      const range = value;
+      if (range.start) {
+        conditions.push(`${field} >= '${range.start.toISOString()}'`);
+      }
+      if (range.end) {
+        conditions.push(`${field} <= '${range.end.toISOString()}'`);
+      }
+    } else if (def.type === "select" && Array.isArray(value)) {
+      if (value.length > 0) {
+        const escaped = value.map((v) => `'${String(v).replace(/'/g, "''")}'`);
+        conditions.push(`${field} IN (${escaped.join(", ")})`);
+      }
+    } else if (def.type === "boolean") {
+      conditions.push(`${field} = ${value ? "true" : "false"}`);
+    } else if (def.type === "text") {
+      conditions.push(`${field} ILIKE '%${String(value).replace(/'/g, "''")}%'`);
+    }
+  }
+  return conditions.length > 0 ? conditions.join(" AND ") : null;
+}
+function parseDateRange(preset) {
+  const now = /* @__PURE__ */ new Date();
+  const end = new Date(now);
+  end.setHours(23, 59, 59, 999);
+  const start = new Date(now);
+  start.setHours(0, 0, 0, 0);
+  switch (preset) {
+    case "today":
+      return { start, end };
+    case "yesterday":
+      start.setDate(start.getDate() - 1);
+      end.setDate(end.getDate() - 1);
+      return { start, end };
+    case "last_7d":
+      start.setDate(start.getDate() - 7);
+      return { start, end };
+    case "last_30d":
+      start.setDate(start.getDate() - 30);
+      return { start, end };
+    case "this_month":
+      start.setDate(1);
+      return { start, end };
+    case "last_month":
+      start.setMonth(start.getMonth() - 1);
+      start.setDate(1);
+      end.setDate(0);
+      return { start, end };
+    case "this_quarter": {
+      const q = Math.floor(now.getMonth() / 3);
+      start.setMonth(q * 3);
+      start.setDate(1);
+      return { start, end };
+    }
+    default:
+      start.setDate(start.getDate() - 7);
+      return { start, end };
+  }
+}
+
+// src/lib/dashboard/renderers/base.ts
+function formatValue(value, format, truncateLen) {
+  if (value === null || value === void 0) {
+    return `${colors.dim}\u2014${RESET}`;
+  }
+  const strValue = String(value);
+  switch (format) {
+    case "number": {
+      const num = typeof value === "number" ? value : parseFloat(strValue);
+      if (isNaN(num)) return strValue;
+      if (num >= 1e6) return `${(num / 1e6).toFixed(1)}M`;
+      if (num >= 1e3) return `${(num / 1e3).toFixed(1)}k`;
+      return num.toLocaleString();
+    }
+    case "currency": {
+      const amount = typeof value === "number" ? value : parseFloat(strValue);
+      if (isNaN(amount)) return strValue;
+      return `$${amount.toFixed(2)}`;
+    }
+    case "percent": {
+      const pct = typeof value === "number" ? value : parseFloat(strValue);
+      if (isNaN(pct)) return strValue;
+      return `${pct.toFixed(1)}%`;
+    }
+    case "duration": {
+      const secs = typeof value === "number" ? value : parseFloat(strValue);
+      if (isNaN(secs)) return strValue;
+      if (secs < 60) return `${secs.toFixed(1)}s`;
+      if (secs < 3600) return `${Math.floor(secs / 60)}m ${Math.round(secs % 60)}s`;
+      return `${Math.floor(secs / 3600)}h ${Math.floor(secs % 3600 / 60)}m`;
+    }
+    case "tokens": {
+      const tokens = typeof value === "number" ? value : parseInt(strValue, 10);
+      if (isNaN(tokens)) return strValue;
+      if (tokens >= 1e6) return `${(tokens / 1e6).toFixed(1)}M`;
+      if (tokens >= 1e3) return `${(tokens / 1e3).toFixed(0)}k`;
+      return tokens.toLocaleString();
+    }
+    case "relative_time":
+      return formatRelativeTime(value);
+    case "relative_date":
+      return formatRelativeDate(value);
+    case "status_badge":
+      return formatStatusBadge(strValue);
+    case "progress_bar": {
+      const progress = typeof value === "number" ? value : parseFloat(strValue);
+      if (isNaN(progress)) return strValue;
+      return progressBar(progress, 8);
+    }
+    default:
+      if (truncateLen && strValue.length > truncateLen) {
+        return truncate(strValue, truncateLen);
+      }
+      return strValue;
+  }
+}
+function formatRelativeTime(value) {
+  const date = value instanceof Date ? value : new Date(String(value));
+  if (isNaN(date.getTime())) return String(value);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffSecs = Math.floor(diffMs / 1e3);
+  const diffMins = Math.floor(diffSecs / 60);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffSecs < 60) return `${diffSecs}s ago`;
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return date.toLocaleDateString();
+}
+function formatRelativeDate(value) {
+  const date = value instanceof Date ? value : new Date(String(value));
+  if (isNaN(date.getTime())) return String(value);
+  const now = /* @__PURE__ */ new Date();
+  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const target = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  const diffDays = Math.floor((today.getTime() - target.getTime()) / (1e3 * 60 * 60 * 24));
+  if (diffDays === 0) return "today";
+  if (diffDays === 1) return "yesterday";
+  if (diffDays < 7) return `${diffDays}d ago`;
+  if (diffDays < 30) return `${Math.floor(diffDays / 7)}w ago`;
+  return date.toLocaleDateString();
+}
+function formatStatusBadge(status) {
+  const lower = status.toLowerCase();
+  switch (lower) {
+    case "success":
+    case "completed":
+    case "active":
+      return `${colors.green}${status}${RESET}`;
+    case "failed":
+    case "error":
+      return `${colors.red}${status}${RESET}`;
+    case "running":
+    case "pending":
+    case "in_progress":
+      return `${colors.yellow}${status}${RESET}`;
+    case "timeout":
+    case "cancelled":
+      return `${colors.dim}${status}${RESET}`;
+    default:
+      return status;
+  }
+}
+function calculateColumnWidths(rows, columns, maxWidth = 80) {
+  const widths = columns.map((col) => {
+    const headerLen = (col.label || col.field).length;
+    const maxValueLen = rows.reduce((max, row) => {
+      const val = String(row[col.field] ?? "");
+      return Math.max(max, val.length);
+    }, 0);
+    return Math.min(Math.max(headerLen, maxValueLen) + 2, 30);
+  });
+  const totalWidth = widths.reduce((sum, w) => sum + w, 0);
+  if (totalWidth > maxWidth) {
+    const scale = maxWidth / totalWidth;
+    return widths.map((w) => Math.max(Math.floor(w * scale), 5));
+  }
+  return widths;
+}
+
+// src/lib/dashboard/renderers/summary.ts
+function renderSummary(view, data, metricDefs) {
+  const lines = [];
+  const row = data.rows[0] || {};
+  const parts = [];
+  for (const metricName of view.metrics || []) {
+    const def = metricDefs.find((m) => m.name === metricName);
+    if (!def) continue;
+    const value = row[metricName];
+    const formatted = formatValue(value, def.format);
+    const label = def.label || metricName;
+    const valueColor = def.format === "currency" ? colors.green : def.format === "percent" ? colors.purple : colors.cyan;
+    parts.push(`${valueColor}${formatted}${RESET} ${colors.dim}${label}${RESET}`);
+  }
+  const line = parts.join(`  ${colors.dim}|${RESET}  `);
+  lines.push(`  ${line}`);
+  return lines;
+}
+
+// src/lib/dashboard/renderers/table.ts
+function renderTable(view, data, metricDefs, dimensionDefs) {
+  const lines = [];
+  if (data.rows.length === 0) {
+    lines.push(`  ${colors.dim}No data${RESET}`);
+    return lines;
+  }
+  const columns = [];
+  if (view.group_by) {
+    for (const dimName of view.group_by) {
+      const def = dimensionDefs.find((d) => d.name === dimName);
+      columns.push({
+        field: dimName,
+        label: def?.label || dimName,
+        format: void 0,
+        width: 0
+        // Will calculate
+      });
+    }
+  }
+  if (view.metrics) {
+    for (const metricName of view.metrics) {
+      const def = metricDefs.find((m) => m.name === metricName);
+      columns.push({
+        field: metricName,
+        label: def?.label || metricName,
+        format: def?.format,
+        width: 0
+      });
+    }
+  }
+  if (view.columns && view.columns.length > 0) {
+    columns.length = 0;
+    for (const col of view.columns) {
+      columns.push({
+        field: col.field,
+        label: col.label || col.field,
+        format: col.format,
+        width: 0
+      });
+    }
+  }
+  const widths = calculateColumnWidths(data.rows, columns, 70);
+  columns.forEach((col, i) => col.width = widths[i]);
+  const tableWidth = columns.reduce((sum, col) => sum + col.width, 0) + columns.length + 1;
+  if (view.title) {
+    lines.push(`  ${bold}${view.title}${RESET}`);
+    lines.push("");
+  }
+  lines.push(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  let headerRow = `  ${colors.purple}${box.vertical}${RESET}`;
+  for (const col of columns) {
+    headerRow += ` ${bold}${padEnd(col.label.toUpperCase(), col.width - 1)}${RESET}`;
+  }
+  headerRow += `${colors.purple}${box.vertical}${RESET}`;
+  lines.push(headerRow);
+  lines.push(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const row of data.rows) {
+    let rowStr = `  ${colors.purple}${box.vertical}${RESET}`;
+    for (const col of columns) {
+      const value = row[col.field];
+      const formatted = formatValue(value, col.format || "string", col.width - 3);
+      const visibleLen = formatted.replace(/\x1b\[[0-9;]*m/g, "").length;
+      const padding = Math.max(0, col.width - 1 - visibleLen);
+      rowStr += ` ${formatted}${" ".repeat(padding)}`;
+    }
+    rowStr += `${colors.purple}${box.vertical}${RESET}`;
+    lines.push(rowStr);
+  }
+  lines.push(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  return lines;
+}
+
+// src/lib/dashboard/renderers/trend.ts
+function renderTrend(view, data, metricDefs) {
+  const lines = [];
+  if (data.rows.length === 0) {
+    lines.push(`  ${colors.dim}No data${RESET}`);
+    return lines;
+  }
+  if (view.title) {
+    lines.push(`  ${bold}${view.title}${RESET}`);
+    lines.push("");
+  }
+  for (const metricName of view.metrics || []) {
+    const def = metricDefs.find((m) => m.name === metricName);
+    if (!def) continue;
+    const values = data.rows.map((row) => {
+      const val = row[metricName];
+      return typeof val === "number" ? val : parseFloat(String(val)) || 0;
+    });
+    const orderedValues = [...values].reverse();
+    const total = orderedValues.reduce((sum, v) => sum + v, 0);
+    const avg = orderedValues.length > 0 ? total / orderedValues.length : 0;
+    const latest = orderedValues[orderedValues.length - 1] || 0;
+    const previous = orderedValues[orderedValues.length - 2] || 0;
+    const change = previous > 0 ? (latest - previous) / previous * 100 : 0;
+    const spark = sparkline(orderedValues);
+    const label = def.label || metricName;
+    const totalFormatted = formatValue(total, def.format);
+    const avgFormatted = formatValue(avg, def.format);
+    const changeColor = change > 0 ? colors.green : change < 0 ? colors.red : colors.dim;
+    const changeSign = change > 0 ? "+" : "";
+    const changeStr = `${changeColor}${changeSign}${change.toFixed(0)}%${RESET}`;
+    lines.push(`  ${colors.dim}${label}:${RESET} ${spark}  ${colors.cyan}${totalFormatted}${RESET} total  ${colors.dim}(avg ${avgFormatted})${RESET}  ${changeStr}`);
+  }
+  return lines;
+}
+function renderStackedTrend(view, data, metricDefs) {
+  const lines = [];
+  if (data.rows.length === 0) {
+    lines.push(`  ${colors.dim}No data${RESET}`);
+    return lines;
+  }
+  if (view.title) {
+    lines.push(`  ${bold}${view.title}${RESET}`);
+    lines.push("");
+  }
+  const primaryMetric = view.metrics?.[0];
+  if (primaryMetric) {
+    const values = data.rows.map((row) => {
+      const val = row[primaryMetric];
+      return typeof val === "number" ? val : parseFloat(String(val)) || 0;
+    }).reverse();
+    const spark = sparkline(values);
+    lines.push(`  ${spark}`);
+    lines.push("");
+  }
+  const legendParts = [];
+  for (const metricName of view.metrics || []) {
+    const def = metricDefs.find((m) => m.name === metricName);
+    if (!def) continue;
+    const total = data.rows.reduce((sum, row) => {
+      const val = row[metricName];
+      return sum + (typeof val === "number" ? val : parseFloat(String(val)) || 0);
+    }, 0);
+    const label = def.label || metricName;
+    const formatted = formatValue(total, def.format);
+    const metricColor = metricName === view.metrics?.[0] ? colors.green : metricName === view.metrics?.[1] ? colors.yellow : colors.red;
+    legendParts.push(`${metricColor}${formatted}${RESET} ${colors.dim}${label}${RESET}`);
+  }
+  lines.push(`  ${legendParts.join("  ")}`);
+  return lines;
+}
+
+// src/lib/dashboard/renderers/bar.ts
+function renderBar(view, data, metricDefs, _dimensionDefs) {
+  const lines = [];
+  if (data.rows.length === 0) {
+    lines.push(`  ${colors.dim}No data${RESET}`);
+    return lines;
+  }
+  if (view.title) {
+    lines.push(`  ${bold}${view.title}${RESET}`);
+    lines.push("");
+  }
+  const dimName = view.group_by?.[0];
+  const metricName = view.metrics?.[0];
+  if (!dimName || !metricName) {
+    lines.push(`  ${colors.dim}Bar chart requires group_by and metrics${RESET}`);
+    return lines;
+  }
+  const metricDef = metricDefs.find((m) => m.name === metricName);
+  const values = data.rows.map((row) => {
+    const val = row[metricName];
+    return typeof val === "number" ? val : parseFloat(String(val)) || 0;
+  });
+  const maxValue = Math.max(...values, 1);
+  const labels = data.rows.map((row) => String(row[dimName] || "Unknown"));
+  const maxLabelWidth = Math.min(Math.max(...labels.map((l) => l.length)), 20);
+  for (const row of data.rows) {
+    const label = String(row[dimName] || "Unknown");
+    const value = row[metricName];
+    const numValue = typeof value === "number" ? value : parseFloat(String(value)) || 0;
+    const bar = barChart(numValue, maxValue, 20);
+    const formatted = formatValue(value, metricDef?.format || "number");
+    lines.push(`  ${colors.cyan}${padEnd(label.slice(0, maxLabelWidth), maxLabelWidth + 1)}${RESET}${bar} ${colors.dim}${formatted}${RESET}`);
+  }
+  return lines;
+}
+function renderPie(view, data, _metricDefs, _dimensionDefs) {
+  const lines = [];
+  if (data.rows.length === 0) {
+    lines.push(`  ${colors.dim}No data${RESET}`);
+    return lines;
+  }
+  if (view.title) {
+    lines.push(`  ${bold}${view.title}${RESET}`);
+    lines.push("");
+  }
+  const dimName = view.group_by?.[0];
+  const metricName = view.metrics?.[0];
+  if (!dimName || !metricName) {
+    lines.push(`  ${colors.dim}Pie chart requires group_by and metrics${RESET}`);
+    return lines;
+  }
+  const values = data.rows.map((row) => {
+    const val = row[metricName];
+    return {
+      label: String(row[dimName] || "Unknown"),
+      value: typeof val === "number" ? val : parseFloat(String(val)) || 0
+    };
+  });
+  const total = values.reduce((sum, v) => sum + v.value, 0);
+  if (total === 0) {
+    lines.push(`  ${colors.dim}No data${RESET}`);
+    return lines;
+  }
+  const colorPalette = [colors.cyan, colors.green, colors.yellow, colors.purple, colors.red];
+  const barWidth = 40;
+  let barStr = "";
+  let pos = 0;
+  for (let i = 0; i < values.length; i++) {
+    const pct = values[i].value / total;
+    const width = Math.max(1, Math.round(pct * barWidth));
+    const color = colorPalette[i % colorPalette.length];
+    barStr += `${color}${"\u2588".repeat(width)}${RESET}`;
+    pos += width;
+  }
+  if (pos < barWidth) {
+    barStr += `${colors.dim}${"\u2591".repeat(barWidth - pos)}${RESET}`;
+  }
+  lines.push(`  ${barStr}`);
+  lines.push("");
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i];
+    const pct = v.value / total * 100;
+    const color = colorPalette[i % colorPalette.length];
+    lines.push(`  ${color}\u25A0${RESET} ${padEnd(v.label.slice(0, 15), 16)} ${color}${pct.toFixed(1)}%${RESET} ${colors.dim}(${v.value.toLocaleString()})${RESET}`);
+  }
+  return lines;
+}
+
+// src/lib/dashboard/renderers/list.ts
+function renderList(view, data) {
+  const lines = [];
+  if (data.rows.length === 0) {
+    lines.push(`  ${colors.dim}No data${RESET}`);
+    return lines;
+  }
+  if (view.title) {
+    lines.push(`  ${bold}${view.title}${RESET}`);
+    lines.push("");
+  }
+  const columns = view.columns || data.columns.map((c) => ({ field: c }));
+  for (const row of data.rows) {
+    const parts = [];
+    for (const col of columns) {
+      const value = row[col.field];
+      let formatted = formatValue(value, col.format || "string", col.truncate);
+      if (col.label) {
+        formatted = `${colors.dim}${col.label}:${RESET} ${formatted}`;
+      }
+      parts.push(formatted);
+    }
+    lines.push(`  ${parts.join("  ")}`);
+  }
+  return lines;
+}
+function renderRecentList(view, data) {
+  const lines = [];
+  if (data.rows.length === 0) {
+    lines.push(`  ${colors.dim}No recent items${RESET}`);
+    return lines;
+  }
+  if (view.title) {
+    lines.push(`  ${bold}${view.title}${RESET}`);
+    lines.push("");
+  }
+  const columns = view.columns || [];
+  const timeCol = columns.find((c) => c.format === "relative_time" || c.field.includes("_at"));
+  for (const row of data.rows) {
+    const parts = [];
+    if (timeCol) {
+      const timeVal = formatValue(row[timeCol.field], "relative_time");
+      parts.push(`${colors.dim}${timeVal}${RESET}`);
+    }
+    for (const col of columns) {
+      if (col === timeCol) continue;
+      const value = row[col.field];
+      const formatted = formatValue(value, col.format || "string", col.truncate);
+      parts.push(formatted);
+    }
+    lines.push(`  ${parts.join("  ")}`);
+  }
+  return lines;
+}
+
+// src/lib/dashboard/renderers/index.ts
+function renderView(view, data, metricDefs, dimensionDefs) {
+  switch (view.type) {
+    case "summary":
+      return renderSummary(view, data, metricDefs);
+    case "table":
+      return renderTable(view, data, metricDefs, dimensionDefs);
+    case "trend":
+      if (view.stacked) {
+        return renderStackedTrend(view, data, metricDefs);
+      }
+      return renderTrend(view, data, metricDefs);
+    case "bar":
+      return renderBar(view, data, metricDefs, dimensionDefs);
+    case "pie":
+      return renderPie(view, data, metricDefs, dimensionDefs);
+    case "list": {
+      const hasTimeCol = view.columns?.some(
+        (c) => c.format === "relative_time" || c.field.includes("_at")
+      );
+      if (hasTimeCol) {
+        return renderRecentList(view, data);
+      }
+      return renderList(view, data);
+    }
+    case "histogram":
+      return [`  ${colors.dim}Histogram not yet implemented${RESET}`];
+    case "heatmap":
+      return [`  ${colors.dim}Heatmap not yet implemented${RESET}`];
+    default:
+      return [`  ${colors.dim}Unknown view type: ${view.type}${RESET}`];
+  }
+}
+
+// src/lib/dashboard/engine.ts
+function getDataSource(sourceName) {
+  switch (sourceName) {
+    case "postgres":
+      return postgresSource;
+    // TODO: Add other sources
+    case "sessions":
+    case "langfuse":
+    case "api":
+      return null;
+    default:
+      return null;
+  }
+}
+async function executeDashboard(name, options = {}) {
+  const lines = [];
+  const def = findDashboard(name);
+  if (!def) {
+    return {
+      success: false,
+      lines: [`${colors.red}Dashboard not found: ${name}${RESET}`]
+    };
+  }
+  const source = getDataSource(def.source);
+  if (!source) {
+    return {
+      success: false,
+      lines: [`${colors.red}Data source not available: ${def.source}${RESET}`]
+    };
+  }
+  const available = await source.isAvailable();
+  if (!available) {
+    return {
+      success: false,
+      lines: [`${colors.red}Cannot connect to ${def.source}${RESET}`]
+    };
+  }
+  const filters = { ...options.filters };
+  for (const filterDef of def.filters || []) {
+    if (filters[filterDef.name] === void 0 && filterDef.default) {
+      if (filterDef.type === "date_range") {
+        filters[filterDef.name] = parseDateRange(filterDef.default);
+      } else {
+        filters[filterDef.name] = filterDef.default;
+      }
+    }
+  }
+  lines.push("");
+  lines.push(`  ${gradient("squads")} ${colors.dim}${def.title}${RESET}`);
+  if (def.description && options.verbose) {
+    lines.push(`  ${colors.dim}${def.description}${RESET}`);
+  }
+  lines.push("");
+  const viewsToRender = options.views ? def.views.filter((v) => options.views.includes(v.id)) : def.views;
+  for (const view of viewsToRender) {
+    try {
+      const data = await fetchViewData(def, view, filters, source);
+      const viewLines = renderView(view, data, def.metrics, def.dimensions || []);
+      lines.push(...viewLines);
+      lines.push("");
+    } catch (err) {
+      if (options.verbose) {
+        lines.push(`  ${colors.red}Error rendering ${view.id}: ${err}${RESET}`);
+      }
+    }
+  }
+  await source.close();
+  return { success: true, lines };
+}
+async function fetchViewData(def, view, filters, source) {
+  if (view.source) {
+    return source.query(view.source);
+  }
+  if (!def.table) {
+    throw new Error("Dashboard requires table or view.source");
+  }
+  const metrics = (view.metrics || []).map((name) => {
+    const m = def.metrics.find((m2) => m2.name === name);
+    if (!m) throw new Error(`Unknown metric: ${name}`);
+    return m;
+  });
+  const filterDefs = def.filters || [];
+  let where = buildWhereClause(filters, filterDefs);
+  if (view.filter) {
+    where = where ? `(${where}) AND (${view.filter})` : view.filter;
+  }
+  const sql = buildQuery(
+    def.table,
+    metrics,
+    view.group_by,
+    where ?? void 0,
+    view.sort,
+    view.limit
+  );
+  return source.query(sql);
+}
+async function renderDashboard(name, options = {}) {
+  const result = await executeDashboard(name, options);
+  for (const line of result.lines) {
+    writeLine(line);
+  }
+  return result.success;
+}
+function showAvailableDashboards() {
+  const names = listDashboards();
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}dashboards${RESET}`);
+  writeLine();
+  if (names.length === 0) {
+    writeLine(`  ${colors.dim}No dashboards found${RESET}`);
+    writeLine(`  ${colors.dim}Create dashboards in .agents/dashboards/*.yaml${RESET}`);
+    writeLine();
+    return;
+  }
+  for (const name of names) {
+    const def = loadDashboard(name);
+    if (def) {
+      writeLine(`  ${colors.cyan}${name.padEnd(16)}${RESET} ${colors.dim}${def.title}${RESET}`);
+    }
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}Usage:${RESET} squads dash ${colors.cyan}<dashboard>${RESET}`);
+  writeLine(`  ${colors.dim}       squads dash ${colors.cyan}<dashboard>${RESET} ${colors.dim}--view=<view-id>${RESET}`);
+  writeLine();
+}
+async function interactiveDashboard(name, initialFilters) {
+  await renderDashboard(name, { filters: initialFilters });
+}
+export {
+  clearDashboardCache,
+  executeDashboard,
+  findDashboard,
+  findDashboardsDir,
+  interactiveDashboard,
+  listDashboards,
+  loadAllDashboards,
+  loadDashboard,
+  postgresSource,
+  renderDashboard,
+  showAvailableDashboards
+};
+//# sourceMappingURL=dashboard-MFNRLCEE.js.map