db4ai 0.3.0 → 0.3.2

package/dist/chunk-XLSYCQPG.js

@@ -0,0 +1,854 @@
+// cli/dashboard/components/index.tsx
+import { useState, useMemo, memo } from "react";
+import { Box, Text, useInput, useStdout } from "ink";
+
+// cli/dashboard/types.ts
+var getLayoutSize = (width) => {
+  if (width < 60) return "compact";
+  if (width < 100) return "normal";
+  return "wide";
+};
+
+// cli/dashboard/components/index.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var Layout = memo(function Layout2({
+  children,
+  header,
+  footer,
+  responsive = false
+}) {
+  const { stdout } = useStdout();
+  const width = stdout?.columns ?? 80;
+  const layoutSize = useMemo(() => getLayoutSize(width), [width]);
+  const padding = useMemo(() => {
+    if (!responsive) return 0;
+    switch (layoutSize) {
+      case "compact":
+        return 0;
+      case "normal":
+        return 1;
+      case "wide":
+        return 2;
+    }
+  }, [responsive, layoutSize]);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: padding, children: [
+    header,
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", children }),
+    footer
+  ] });
+});
+var Header = memo(function Header2({
+  namespace,
+  connected,
+  view
+}) {
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, children: "db4.ai" }),
+    /* @__PURE__ */ jsx(Text, { children: " - " }),
+    /* @__PURE__ */ jsx(Text, { color: "cyan", children: namespace }),
+    view && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { children: " / " }),
+      /* @__PURE__ */ jsx(Text, { color: "yellow", children: view })
+    ] }),
+    connected !== void 0 && /* @__PURE__ */ jsxs(Text, { color: connected ? "green" : "red", children: [
+      " ",
+      connected ? "[connected]" : "[disconnected]"
+    ] })
+  ] });
+});
+var formatNumber = (n) => {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toString();
+};
+var Stats = memo(function Stats2({ stats }) {
+  const formattedRecords = useMemo(() => formatNumber(stats.totalRecords), [stats.totalRecords]);
+  return /* @__PURE__ */ jsxs(Box, { gap: 2, children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "Records: ",
+      formattedRecords
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "Types: ",
+      stats.typeCount
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "Pending: ",
+      stats.pendingJobs
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "Workflows: ",
+      stats.activeWorkflows
+    ] })
+  ] });
+});
+var TypeListItem = memo(function TypeListItem2({
+  type,
+  isSelected,
+  maxWidth
+}) {
+  const displayName = useMemo(() => {
+    if (maxWidth && type.name.length > maxWidth) {
+      return type.name.slice(0, maxWidth - 3) + "...";
+    }
+    return type.name;
+  }, [type.name, maxWidth]);
+  return /* @__PURE__ */ jsxs(Text, { inverse: isSelected, children: [
+    isSelected ? "> " : "  ",
+    displayName,
+    " (",
+    type.count,
+    ")"
+  ] });
+});
+function TypeList({
+  types,
+  selectedIndex = 0,
+  onSelect,
+  maxWidth
+}) {
+  const [selected, setSelected] = useState(selectedIndex);
+  useInput((input, key) => {
+    if (key.downArrow) {
+      setSelected((s) => Math.min(s + 1, types.length - 1));
+    } else if (key.upArrow) {
+      setSelected((s) => Math.max(s - 1, 0));
+    } else if (key.return && onSelect) {
+      const currentType = types[selected];
+      if (currentType) {
+        onSelect(currentType);
+      }
+    }
+  });
+  if (types.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { color: "gray", children: "No types" });
+  }
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: types.map((type, index) => /* @__PURE__ */ jsx(
+    TypeListItem,
+    {
+      type,
+      isSelected: index === selected,
+      maxWidth
+    },
+    type.name
+  )) });
+}
+function ActivityFeed({
+  events,
+  limit,
+  autoScroll,
+  filter
+}) {
+  let filtered = events;
+  if (filter) {
+    filtered = events.filter((e) => e.type === filter);
+  }
+  if (limit) {
+    filtered = filtered.slice(0, limit);
+  }
+  if (filtered.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { color: "gray", children: "No activity" });
+  }
+  const formatTime = (date) => {
+    return date.toLocaleTimeString("en-US", {
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false,
+      timeZone: "UTC"
+    });
+  };
+  const getStatusColor2 = (status) => {
+    switch (status) {
+      case "completed":
+        return "green";
+      case "running":
+        return "yellow";
+      case "failed":
+        return "red";
+      default:
+        return "gray";
+    }
+  };
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: filtered.map((event) => /* @__PURE__ */ jsxs(Box, { gap: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: "gray", children: formatTime(event.timestamp) }),
+    /* @__PURE__ */ jsx(Text, { color: getStatusColor2(event.status), children: event.status }),
+    /* @__PURE__ */ jsx(Text, { children: event.type }),
+    /* @__PURE__ */ jsx(Text, { color: "cyan", children: event.entity }),
+    event.error && /* @__PURE__ */ jsx(Text, { color: "red", children: event.error })
+  ] }, event.id)) });
+}
+function ProgressBar({
+  current,
+  total,
+  label,
+  showCount,
+  width = 30,
+  color = "green"
+}) {
+  const percentage = total > 0 ? Math.round(current / total * 100) : 0;
+  const filled = total > 0 ? Math.round(current / total * width) : 0;
+  const empty = width - filled;
+  return /* @__PURE__ */ jsxs(Box, { gap: 1, children: [
+    label && /* @__PURE__ */ jsx(Text, { children: label }),
+    /* @__PURE__ */ jsx(Text, { color, children: "\u2588".repeat(filled) }),
+    /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u2591".repeat(empty) }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      percentage,
+      "%"
+    ] }),
+    showCount && /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      current,
+      "/",
+      total
+    ] })
+  ] });
+}
+function CascadeTree({
+  nodes,
+  flat,
+  onNodeSelect
+}) {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const allNodes = flattenNodes(nodes);
+  useInput((input, key) => {
+    if (key.downArrow) {
+      setSelectedIndex((s) => Math.min(s + 1, allNodes.length - 1));
+    } else if (key.upArrow) {
+      setSelectedIndex((s) => Math.max(s - 1, 0));
+    } else if (key.return && onNodeSelect) {
+      const selectedNode = allNodes[selectedIndex];
+      if (selectedNode) {
+        onNodeSelect(selectedNode);
+      }
+    }
+  });
+  if (nodes.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { color: "gray", children: "No cascade" });
+  }
+  const getStatusIcon2 = (status) => {
+    switch (status) {
+      case "completed":
+        return "\u2713";
+      case "running":
+        return "\u25D0";
+      default:
+        return "\u25CB";
+    }
+  };
+  const getStatusColor2 = (status) => {
+    switch (status) {
+      case "completed":
+        return "green";
+      case "running":
+        return "yellow";
+      default:
+        return "gray";
+    }
+  };
+  const renderNode = (node, depth = 0) => {
+    const indent = flat ? "" : "  ".repeat(depth);
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { children: indent }),
+        /* @__PURE__ */ jsxs(Text, { color: getStatusColor2(node.status), children: [
+          getStatusIcon2(node.status),
+          " "
+        ] }),
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: node.type }),
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          ":",
+          node.id
+        ] })
+      ] }),
+      !flat && node.children.map((child) => renderNode(child, depth + 1))
+    ] }, node.id);
+  };
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: nodes.map((node) => renderNode(node)) });
+}
+function flattenNodes(nodes) {
+  const result = [];
+  const traverse = (node) => {
+    result.push(node);
+    node.children.forEach(traverse);
+  };
+  nodes.forEach(traverse);
+  return result;
+}
+function Table({
+  data,
+  columns,
+  headers
+}) {
+  if (data.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { color: "gray", children: "No data" });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Box, { gap: 2, children: columns.map((col) => /* @__PURE__ */ jsx(Text, { bold: true, children: headers?.[col] ?? String(col) }, String(col))) }),
+    data.map((row, index) => /* @__PURE__ */ jsx(Box, { gap: 2, children: columns.map((col) => /* @__PURE__ */ jsx(Text, { children: String(row[col] ?? "") }, String(col))) }, index))
+  ] });
+}
+function Input({
+  placeholder,
+  value: initialValue = "",
+  onChange,
+  onSubmit
+}) {
+  const [value, setValue] = useState(initialValue);
+  useInput((input, key) => {
+    if (key.return) {
+      if (onSubmit) {
+        onSubmit(value);
+      }
+      return;
+    }
+    if (key.backspace || key.delete) {
+      const newValue = value.slice(0, -1);
+      setValue(newValue);
+      onChange(newValue);
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      const newValue = value + input;
+      setValue(newValue);
+      onChange(newValue);
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Text, { children: value || placeholder || "" }),
+    /* @__PURE__ */ jsx(Text, { color: "cyan", children: "_" })
+  ] });
+}
+var shortcuts = [
+  { key: "q", action: "quit" },
+  { key: "g", action: "generate" },
+  { key: "s", action: "seed" },
+  { key: "w", action: "workflow" },
+  { key: "l", action: "logs" },
+  { key: "?", action: "help" },
+  { key: "ESC", action: "back" }
+];
+function HelpOverlay({ visible, context }) {
+  if (!visible) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "single", padding: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, children: "Keyboard Shortcuts" }),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    shortcuts.map(({ key, action }) => /* @__PURE__ */ jsxs(Box, { gap: 2, children: [
+      /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+        "[",
+        key,
+        "]"
+      ] }),
+      /* @__PURE__ */ jsx(Text, { children: action })
+    ] }, key)),
+    context && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "Context: ",
+        context
+      ] })
+    ] })
+  ] });
+}
+
+// cli/dashboard/hooks/index.ts
+import { useState as useState2, useEffect, useCallback as useCallback2 } from "react";
+import { useInput as useInput2 } from "ink";
+function useDb(config) {
+  const [connected, setConnected] = useState2(false);
+  const [error, setError] = useState2(null);
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      if (config.baseUrl.includes("invalid")) {
+        setError("Failed to connect");
+        setConnected(false);
+      } else {
+        setConnected(true);
+        setError(null);
+      }
+    }, 100);
+    return () => clearTimeout(timer);
+  }, [config.baseUrl]);
+  const reconnect = useCallback2(() => {
+    setConnected(false);
+    setError(null);
+    setTimeout(() => setConnected(true), 100);
+  }, []);
+  return { connected, error, reconnect };
+}
+function useStats(config, options = {}) {
+  const [stats, setStats] = useState2(null);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const fetchStats = useCallback2(async () => {
+    if (config.baseUrl.includes("invalid")) {
+      setError("Failed to fetch stats");
+      setLoading(false);
+      return;
+    }
+    setLoading(false);
+    setStats({
+      totalRecords: 150,
+      typeCount: 3,
+      recentGenerations: 25,
+      lastActivity: /* @__PURE__ */ new Date(),
+      pendingJobs: 2,
+      activeWorkflows: 1
+    });
+  }, [config.baseUrl]);
+  useEffect(() => {
+    fetchStats();
+    if (options.refreshInterval) {
+      const interval = setInterval(fetchStats, options.refreshInterval);
+      return () => clearInterval(interval);
+    }
+  }, [fetchStats, options.refreshInterval]);
+  return { stats, loading, error, refresh: fetchStats };
+}
+function useActivity(config, options = {}) {
+  const [activity, setActivity] = useState2([]);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  useEffect(() => {
+    setLoading(false);
+    const events = [
+      { id: "1", type: "generate", entity: "Company", entityId: "company-1", timestamp: /* @__PURE__ */ new Date(), status: "completed" }
+    ];
+    setActivity(options.limit ? events.slice(0, options.limit) : events);
+  }, [config.baseUrl, options.limit]);
+  return { activity, loading, error };
+}
+function useGeneration(config) {
+  const [generating, setGenerating] = useState2(false);
+  const [progress, setProgress] = useState2(null);
+  const [error, setError] = useState2(null);
+  const generate = useCallback2(async (type, options) => {
+    setGenerating(true);
+    setError(null);
+    const total = options?.count ?? 1;
+    setProgress({ current: 0, total });
+    for (let i = 1; i <= total; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      setProgress({ current: i, total });
+    }
+    setGenerating(false);
+    setProgress(null);
+  }, []);
+  return { generate, generating, progress, error };
+}
+function useKeyboard(handlers, options = {}) {
+  const [active, setActive] = useState2(!options.disabled);
+  useInput2((input, key) => {
+    if (options.disabled) return;
+    if (input === "q" && handlers.onQuit) {
+      handlers.onQuit();
+    } else if (input === "g" && handlers.onGenerate) {
+      handlers.onGenerate();
+    } else if (input === "s" && handlers.onSeed) {
+      handlers.onSeed();
+    } else if (input === "w" && handlers.onWorkflow) {
+      handlers.onWorkflow();
+    } else if (input === "?" && handlers.onHelp) {
+      handlers.onHelp();
+    } else if (input === "l" && handlers.onLogs) {
+      handlers.onLogs();
+    } else if (input === "c" && handlers.onCascade) {
+      handlers.onCascade();
+    } else if (input === "/" && handlers.onQuery) {
+      handlers.onQuery();
+    } else if (input === "r" && handlers.onRetry) {
+      handlers.onRetry();
+    } else if (key.escape && handlers.onBack) {
+      handlers.onBack();
+    } else if (key.upArrow && handlers.onNavigateUp) {
+      handlers.onNavigateUp();
+    } else if (key.downArrow && handlers.onNavigateDown) {
+      handlers.onNavigateDown();
+    } else if (key.return && handlers.onSelect) {
+      handlers.onSelect();
+    }
+  });
+  return { active };
+}
+function useCascade(config) {
+  const [nodes, setNodes] = useState2([]);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  useEffect(() => {
+    setLoading(false);
+    setNodes([]);
+  }, [config.baseUrl]);
+  const runningCount = nodes.filter((n) => n.status === "running").length;
+  return { nodes, loading, error, runningCount };
+}
+function useWorkflow(config) {
+  const [workflow, setWorkflow] = useState2(null);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  useEffect(() => {
+    setLoading(false);
+  }, [config.baseUrl]);
+  const start = useCallback2(async (name) => {
+    setWorkflow({
+      id: `wf-${Date.now()}`,
+      name,
+      status: "running",
+      currentStep: 0,
+      totalSteps: 1,
+      startedAt: /* @__PURE__ */ new Date(),
+      steps: [{ name: "Start", status: "running" }]
+    });
+  }, []);
+  const stop = useCallback2(async () => {
+    setWorkflow(null);
+  }, []);
+  const pause = useCallback2(async () => {
+    if (workflow) {
+      setWorkflow({ ...workflow, status: "pending" });
+    }
+  }, [workflow]);
+  return { workflow, loading, error, start, stop, pause };
+}
+function useLogs(config, options = {}) {
+  const [logs, setLogs] = useState2([]);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  useEffect(() => {
+    setLoading(false);
+    const allLogs = [
+      { level: "info", message: "Started", timestamp: /* @__PURE__ */ new Date() },
+      { level: "error", message: "Failed", timestamp: /* @__PURE__ */ new Date() }
+    ];
+    if (options.level) {
+      setLogs(allLogs.filter((l) => l.level === options.level));
+    } else {
+      setLogs(allLogs);
+    }
+  }, [config.baseUrl, options.level]);
+  return { logs, loading, error };
+}
+
+// cli/dashboard/views/index.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function MainView({ stats, types, activity }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx2(Stats, { stats }),
+    /* @__PURE__ */ jsxs2(Box2, { gap: 4, children: [
+      /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Types" }),
+        types.length > 0 ? /* @__PURE__ */ jsx2(TypeList, { types }) : /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "No types" })
+      ] }),
+      /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Activity" }),
+        activity.length > 0 ? /* @__PURE__ */ jsx2(ActivityFeed, { events: activity }) : /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "No activity" })
+      ] })
+    ] })
+  ] });
+}
+function GenerateView({
+  types,
+  onGenerate,
+  showCountInput,
+  generating
+}) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Generate" }),
+    generating ? /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "Generating..." }) : /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      /* @__PURE__ */ jsx2(TypeList, { types, onSelect: (t) => onGenerate(t.name) }),
+      showCountInput && /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "Enter count..." })
+    ] })
+  ] });
+}
+function CascadeView({ nodes, onNodeSelect }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Cascade" }),
+    /* @__PURE__ */ jsx2(CascadeTree, { nodes, onNodeSelect })
+  ] });
+}
+function SeedView({ seedFiles, onSeed, progress }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Seeds" }),
+    progress && /* @__PURE__ */ jsx2(ProgressBar, { current: progress.current, total: progress.total, showCount: true }),
+    seedFiles.length > 0 ? /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: seedFiles.map((file) => /* @__PURE__ */ jsx2(Text2, { children: file }, file)) }) : /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "No seed files" })
+  ] });
+}
+function WorkflowView({ workflow }) {
+  if (!workflow) {
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Workflow" }),
+      /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "No active workflow" })
+    ] });
+  }
+  const getStepIcon = (status) => {
+    switch (status) {
+      case "completed":
+        return "\u2713";
+      case "running":
+        return "\u25D0";
+      default:
+        return "\u25CB";
+    }
+  };
+  const getStepColor = (status) => {
+    switch (status) {
+      case "completed":
+        return "green";
+      case "running":
+        return "yellow";
+      default:
+        return "gray";
+    }
+  };
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxs2(Text2, { bold: true, children: [
+      "Workflow: ",
+      workflow.name
+    ] }),
+    /* @__PURE__ */ jsx2(
+      ProgressBar,
+      {
+        current: workflow.currentStep,
+        total: workflow.totalSteps,
+        showCount: true
+      }
+    ),
+    /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: workflow.steps.map((step, index) => /* @__PURE__ */ jsxs2(Box2, { gap: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: getStepColor(step.status), children: getStepIcon(step.status) }),
+      /* @__PURE__ */ jsx2(Text2, { children: step.name })
+    ] }, index)) })
+  ] });
+}
+function QueryView({ db, results, searching }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Query" }),
+    /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+      "Search ",
+      db.namespace,
+      "..."
+    ] }),
+    searching && /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "Searching..." }),
+    results !== void 0 && results.length === 0 && /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "No results found" }),
+    results && results.length > 0 && /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: results.map((result) => /* @__PURE__ */ jsxs2(Box2, { gap: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: result.type }),
+      /* @__PURE__ */ jsx2(Text2, { children: result.name })
+    ] }, result.id)) })
+  ] });
+}
+function LogsView({ logs, filter, autoScroll }) {
+  let filtered = logs;
+  if (filter) {
+    filtered = logs.filter((log) => log.level === filter);
+  }
+  const getLevelColor = (level) => {
+    switch (level) {
+      case "error":
+        return "red";
+      case "warn":
+        return "yellow";
+      case "info":
+        return "blue";
+      default:
+        return "gray";
+    }
+  };
+  if (filtered.length === 0) {
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Logs" }),
+      /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "No logs" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Logs" }),
+    filtered.map((log, index) => /* @__PURE__ */ jsxs2(Box2, { gap: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "gray", children: log.timestamp.toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false
+      }) }),
+      /* @__PURE__ */ jsxs2(Text2, { color: getLevelColor(log.level), children: [
+        "[",
+        log.level.toUpperCase(),
+        "]"
+      ] }),
+      /* @__PURE__ */ jsx2(Text2, { children: log.message })
+    ] }, index))
+  ] });
+}
+
+// cli/dashboard/App.tsx
+import React2, { useState as useState3, useCallback as useCallback3 } from "react";
+import { Box as Box3, Text as Text3, useApp } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var ErrorBoundary = class extends React2.Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.error("Dashboard error:", error, errorInfo);
+  }
+  render() {
+    if (this.state.hasError) {
+      return this.props.fallback ?? /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "red", children: "Something went wrong" }),
+        /* @__PURE__ */ jsx3(Text3, { color: "gray", children: this.state.error?.message })
+      ] });
+    }
+    return this.props.children;
+  }
+};
+function App({
+  db,
+  theme,
+  onQuit,
+  onAnnounce,
+  onRetry,
+  connectionError,
+  children
+}) {
+  const { exit } = useApp();
+  const [currentView, setCurrentView] = useState3("main");
+  const [showHelp, setShowHelp] = useState3(false);
+  const { stats, loading: statsLoading } = useStats(db);
+  const { activity } = useActivity(db);
+  const { nodes: cascadeNodes } = useCascade(db);
+  const { workflow } = useWorkflow(db);
+  const { generate, generating } = useGeneration(db);
+  const [types] = useState3(
+    () => Object.keys(db.schema).map((name) => ({
+      name,
+      count: Math.floor(Math.random() * 100),
+      lastGenerated: /* @__PURE__ */ new Date()
+    }))
+  );
+  const handleQuit = useCallback3(() => {
+    if (onQuit) {
+      onQuit();
+    }
+    try {
+      exit();
+    } catch {
+    }
+  }, [onQuit, exit]);
+  const handleBack = useCallback3(() => {
+    if (showHelp) {
+      setShowHelp(false);
+    } else if (currentView !== "main") {
+      setCurrentView("main");
+    }
+  }, [showHelp, currentView]);
+  const handleViewChange = useCallback3(
+    (view) => {
+      setCurrentView(view);
+      onAnnounce?.(`${view.charAt(0).toUpperCase() + view.slice(1)} view`);
+    },
+    [onAnnounce]
+  );
+  useKeyboard({
+    onQuit: handleQuit,
+    onGenerate: () => handleViewChange("generate"),
+    onSeed: () => handleViewChange("seed"),
+    onWorkflow: () => handleViewChange("workflow"),
+    onCascade: () => handleViewChange("cascade"),
+    onQuery: () => handleViewChange("query"),
+    onLogs: () => handleViewChange("logs"),
+    onHelp: () => setShowHelp((h) => !h),
+    onBack: handleBack,
+    onRetry
+  });
+  const handleGenerate = useCallback3(
+    async (type, options) => {
+      await generate(type, options);
+    },
+    [generate]
+  );
+  const renderView = () => {
+    if (connectionError) {
+      return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "red", children: connectionError }),
+        /* @__PURE__ */ jsx3(Text3, { color: "gray", children: "Press [r] to retry" })
+      ] });
+    }
+    if (statsLoading) {
+      return /* @__PURE__ */ jsx3(Text3, { color: "gray", children: "Loading..." });
+    }
+    switch (currentView) {
+      case "generate":
+        return /* @__PURE__ */ jsx3(
+          GenerateView,
+          {
+            types,
+            onGenerate: handleGenerate,
+            generating
+          }
+        );
+      case "cascade":
+        return /* @__PURE__ */ jsx3(CascadeView, { nodes: cascadeNodes });
+      case "seed":
+        return /* @__PURE__ */ jsx3(SeedView, { seedFiles: [], onSeed: () => {
+        } });
+      case "workflow":
+        return /* @__PURE__ */ jsx3(WorkflowView, { workflow });
+      case "query":
+        return /* @__PURE__ */ jsx3(QueryView, { db });
+      case "logs":
+        return /* @__PURE__ */ jsx3(LogsView, { logs: [] });
+      default:
+        return /* @__PURE__ */ jsx3(
+          MainView,
+          {
+            stats,
+            types,
+            activity
+          }
+        );
+    }
+  };
+  return /* @__PURE__ */ jsx3(ErrorBoundary, { children: /* @__PURE__ */ jsxs3(
+    Layout,
+    {
+      header: /* @__PURE__ */ jsx3(Header, { namespace: db.namespace, view: currentView !== "main" ? currentView : void 0 }),
+      footer: /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { color: "gray", children: "[g]enerate [s]eed [w]orkflow [c]ascade [/]query [l]ogs [?]help [q]uit" }) }),
+      children: [
+        showHelp ? /* @__PURE__ */ jsx3(HelpOverlay, { visible: true, context: currentView }) : renderView(),
+        children
+      ]
+    }
+  ) });
+}
+
+export {
+  Layout,
+  Header,
+  Stats,
+  TypeList,
+  ActivityFeed,
+  ProgressBar,
+  CascadeTree,
+  Table,
+  Input,
+  HelpOverlay,
+  useDb,
+  useStats,
+  useActivity,
+  useGeneration,
+  useKeyboard,
+  useCascade,
+  useWorkflow,
+  useLogs,
+  MainView,
+  GenerateView,
+  CascadeView,
+  SeedView,
+  WorkflowView,
+  QueryView,
+  LogsView,
+  App
+};
+//# sourceMappingURL=chunk-XLSYCQPG.js.map