@dbsp/cli 1.0.0

package/dist/repl-4OFERLKZ.js

@@ -0,0 +1,1454 @@
+import {
+  ReplEngine,
+  getDatabaseName
+} from "./chunk-ZSGVJFWG.js";
+import {
+  config
+} from "./chunk-U5DSGBS2.js";
+
+// src/repl/index.tsx
+import { Box as Box10, render, useApp, useInput as useInput3 } from "ink";
+import React10, {
+  useCallback as useCallback2,
+  useEffect as useEffect3,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useState as useState3
+} from "react";
+
+// src/repl/components/CompletionDisplay.tsx
+import React from "react";
+import { Box, Text } from "ink";
+var TYPE_ICONS = {
+  table: "\u{1F5C3}\uFE0F",
+  column: "\u{1F4CB}",
+  keyword: "\u{1F511}",
+  command: "\u26A1",
+  relation: "\u{1F517}"
+};
+var TYPE_COLORS = {
+  table: "cyan",
+  column: "blue",
+  keyword: "yellow",
+  command: "magenta",
+  relation: "green"
+};
+function CompletionDisplay({
+  suggestions,
+  maxItems = 8,
+  selectedIndex = -1
+}) {
+  if (suggestions.length === 0) {
+    return null;
+  }
+  let startIndex = 0;
+  if (selectedIndex >= 0) {
+    const halfWindow = Math.floor(maxItems / 2);
+    startIndex = Math.max(
+      0,
+      Math.min(selectedIndex - halfWindow, suggestions.length - maxItems)
+    );
+  }
+  startIndex = Math.max(0, startIndex);
+  const endIndex = Math.min(startIndex + maxItems, suggestions.length);
+  const items = suggestions.slice(startIndex, endIndex);
+  const hasBefore = startIndex > 0;
+  const hasAfter = endIndex < suggestions.length;
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row", flexWrap: "wrap", marginTop: 0 }, /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "[Tab]", " "), hasBefore && /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "\u25C0", " "), items.map((suggestion, idx) => {
+    const globalIndex = startIndex + idx;
+    const isSelected = globalIndex === selectedIndex;
+    return /* @__PURE__ */ React.createElement(Box, { key: globalIndex, marginRight: 1 }, /* @__PURE__ */ React.createElement(Text, null, TYPE_ICONS[suggestion.type], " "), /* @__PURE__ */ React.createElement(
+      Text,
+      {
+        color: isSelected ? "white" : TYPE_COLORS[suggestion.type],
+        ...isSelected && { backgroundColor: "blue" },
+        bold: isSelected
+      },
+      suggestion.label
+    ));
+  }), hasAfter && /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "\u25B6 +", suggestions.length - endIndex));
+}
+
+// src/repl/components/Header.tsx
+import React2 from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+var DIALECT_DISPLAY = {
+  postgresql: "PG",
+  mysql: "MySQL",
+  sqlite: "SQLite",
+  mssql: "MSSQL",
+  duckdb: "DuckDB"
+};
+var STRATEGY_DISPLAY = {
+  auto: "auto",
+  join: "join",
+  subquery: "sep",
+  cte: "cte",
+  lateral: "lat",
+  json_agg: "json"
+};
+function Header({
+  schemaPath,
+  mode,
+  tableCount,
+  relationCount,
+  dialect,
+  includeStrategy,
+  aliasingMode,
+  connected,
+  execMode,
+  databaseName,
+  schemaName,
+  parseMode,
+  explainMode
+}) {
+  return /* @__PURE__ */ React2.createElement(
+    Box2,
+    {
+      borderStyle: "round",
+      borderColor: "cyan",
+      paddingX: 2,
+      marginBottom: 1,
+      flexDirection: "column"
+    },
+    /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, "\u{1F50D} db-semantic-planner REPL"), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " | "), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, ".help for commands"), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " | "), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "Ctrl+C to exit")),
+    /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "Schema: "), /* @__PURE__ */ React2.createElement(Text2, { color: "white" }, schemaPath), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " ", "(", tableCount, " tables, ", relationCount, " relations)"), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " | Mode: "), /* @__PURE__ */ React2.createElement(Text2, { color: mode === "natural" ? "green" : "yellow" }, mode), schemaName && /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " | Schema: "), /* @__PURE__ */ React2.createElement(Text2, { color: "cyan" }, schemaName))),
+    /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "Dialect: "), /* @__PURE__ */ React2.createElement(Text2, { color: "blue" }, DIALECT_DISPLAY[dialect]), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " | Strategy: "), /* @__PURE__ */ React2.createElement(Text2, { color: "magenta" }, STRATEGY_DISPLAY[includeStrategy]), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " | Alias: "), /* @__PURE__ */ React2.createElement(Text2, { color: aliasingMode === "always" ? "cyan" : "yellow" }, aliasingMode === "always" ? "all" : "collision"), parseMode && /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " | "), /* @__PURE__ */ React2.createElement(Text2, { color: "blue" }, "[parse]")), explainMode && /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " | "), /* @__PURE__ */ React2.createElement(Text2, { color: "yellow" }, "[explain]")), connected && /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " | "), /* @__PURE__ */ React2.createElement(Text2, { color: "green" }, "DB: ", databaseName)), connected && /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " | "), /* @__PURE__ */ React2.createElement(Text2, { color: execMode ? "green" : "gray" }, "[exec: ", execMode ? "ON" : "OFF", "]")))
+  );
+}
+
+// src/repl/components/HelpDisplay.tsx
+import React3 from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+var DOT_COMMANDS = [
+  { command: ".help", description: "Show this help" },
+  { command: ".tables", description: "List all tables in schema" },
+  {
+    command: ".schema [table]",
+    description: "Show schema info (or specific table)"
+  },
+  { command: ".relations", description: "List all relations" },
+  {
+    command: ".history",
+    description: "Show command history (\u2191/\u2193 to navigate, Ctrl+R to search)"
+  },
+  {
+    command: ".sql",
+    description: "SQL mode: input is raw SQL, ! escapes to natural"
+  },
+  {
+    command: ".natural",
+    description: "Natural mode: input is parsed, ! escapes to SQL"
+  },
+  {
+    command: ".use [schema]",
+    description: "Set schema for queries (empty to clear)"
+  },
+  { command: ".split", description: "Toggle split view (schema | query)" },
+  {
+    command: ".aliasing",
+    description: "Toggle column aliasing mode (always/onCollision)"
+  },
+  {
+    command: ".strategy [mode]",
+    description: "Show/set include strategy (auto|join|separate|cte|lateral|json_agg)"
+  },
+  {
+    command: ".dialect [name]",
+    description: "Show/set SQL dialect (postgresql|mysql|sqlite|mssql|duckdb)"
+  },
+  {
+    command: ".exec [on|off]",
+    description: "Toggle execution mode (requires --db connection)"
+  },
+  {
+    command: ".import <file>",
+    description: "Execute SQL file (DDL, seed data)"
+  },
+  {
+    command: ".parse [on|off]",
+    description: "Toggle parse tree (AST) output for queries"
+  },
+  {
+    command: ".explain [on|off]",
+    description: "Toggle EXPLAIN prefix for queries"
+  },
+  {
+    command: ".table [option] [value]",
+    description: "Configure table display (borders, overflow, headers, padding)"
+  },
+  { command: ".clear", description: "Clear screen and output" },
+  { command: ".exit / .quit", description: "Exit REPL" }
+];
+var NATURAL_SYNTAX = [
+  {
+    pattern: "<table>",
+    example: "users",
+    description: "Select all from table"
+  },
+  {
+    pattern: "<table> where <cond>",
+    example: "users where active = true",
+    description: "Filter results"
+  },
+  {
+    pattern: "<table> include <rel>",
+    example: "users include posts",
+    description: "Include related data"
+  },
+  {
+    pattern: "<table> limit <n>",
+    example: "users limit 10",
+    description: "Limit results"
+  },
+  {
+    pattern: "!<query>",
+    example: "!SELECT... or !users",
+    description: "Mode escape: SQL in natural mode, natural in SQL mode"
+  }
+];
+function SimpleTable({
+  data,
+  columns
+}) {
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, data.map((row, i) => /* @__PURE__ */ React3.createElement(Box3, { key: i }, columns.map((col, j) => /* @__PURE__ */ React3.createElement(Box3, { key: col, width: col === "description" ? 50 : 25 }, /* @__PURE__ */ React3.createElement(Text3, { color: j === 0 ? "cyan" : "white" }, row[col]))))));
+}
+function HelpDisplay() {
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "yellow" }, "\u{1F4DA} Dot Commands:"), /* @__PURE__ */ React3.createElement(Box3, { marginTop: 1, marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React3.createElement(SimpleTable, { data: DOT_COMMANDS, columns: ["command", "description"] })), /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "cyan" }, "\u{1F4DD} Natural Query Syntax:"), /* @__PURE__ */ React3.createElement(Box3, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React3.createElement(
+    SimpleTable,
+    {
+      data: NATURAL_SYNTAX,
+      columns: ["pattern", "example", "description"]
+    }
+  )), /* @__PURE__ */ React3.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: "gray" }, "Tip: Use .sql to switch to raw SQL mode, .natural to return")));
+}
+
+// src/repl/components/InputPrompt.tsx
+import React5 from "react";
+import { Box as Box5, Text as Text5, useInput as useInput2 } from "ink";
+import { useCallback, useEffect as useEffect2, useMemo, useState as useState2 } from "react";
+
+// src/repl/components/EnhancedTextInput.tsx
+import { Box as Box4, Text as Text4, useInput, useStdin, useStdout } from "ink";
+import React4, { useEffect, useRef, useState } from "react";
+function findPrevWordStart(text, cursor) {
+  if (cursor <= 0) return 0;
+  let pos = cursor - 1;
+  while (pos > 0 && text[pos] === " ") {
+    pos--;
+  }
+  while (pos > 0 && text[pos - 1] !== " ") {
+    pos--;
+  }
+  return pos;
+}
+function findNextWordEnd(text, cursor) {
+  if (cursor >= text.length) return text.length;
+  let pos = cursor;
+  while (pos < text.length && text[pos] === " ") {
+    pos++;
+  }
+  while (pos < text.length && text[pos] !== " ") {
+    pos++;
+  }
+  return pos;
+}
+function EnhancedTextInput({
+  value: controlledValue,
+  defaultValue = "",
+  placeholder = "",
+  onChange,
+  onSubmit,
+  isDisabled = false,
+  isFocused = true
+}) {
+  const [internalValue, setInternalValue] = useState(defaultValue);
+  const [cursor, setCursor] = useState(defaultValue.length);
+  const valueRef = useRef(defaultValue);
+  const cursorRef = useRef(defaultValue.length);
+  const { stdout } = useStdout();
+  const lastRawInputRef = useRef("");
+  const { stdin } = useStdin();
+  useEffect(() => {
+    if (!stdin || isDisabled || !isFocused) return;
+    const handleRawData = (data) => {
+      lastRawInputRef.current = data.toString();
+    };
+    stdin.on("data", handleRawData);
+    return () => {
+      stdin.off("data", handleRawData);
+    };
+  }, [stdin, isDisabled, isFocused]);
+  const value = controlledValue ?? internalValue;
+  useEffect(() => {
+    if (controlledValue !== void 0) {
+      const synced = Math.min(cursorRef.current, controlledValue.length);
+      cursorRef.current = synced;
+      setCursor(synced);
+      valueRef.current = controlledValue;
+    }
+  }, [controlledValue]);
+  useEffect(() => {
+    if (controlledValue === void 0) {
+      setInternalValue(defaultValue);
+      setCursor(defaultValue.length);
+      valueRef.current = defaultValue;
+      cursorRef.current = defaultValue.length;
+    }
+  }, [defaultValue, controlledValue]);
+  const updateValue = (newValue, newCursor) => {
+    const nc = newCursor ?? newValue.length;
+    valueRef.current = newValue;
+    cursorRef.current = nc;
+    if (controlledValue === void 0) {
+      setInternalValue(newValue);
+    }
+    setCursor(nc);
+    onChange?.(newValue);
+  };
+  useInput(
+    (input, key) => {
+      if (isDisabled || !isFocused) return;
+      const val = valueRef.current;
+      const cur = cursorRef.current;
+      if (key.return) {
+        if (key.shift) {
+          const newValue = `${val.slice(0, cur)}
+${val.slice(cur)}`;
+          updateValue(newValue, cur + 1);
+          return;
+        }
+        if (val.endsWith("\\")) {
+          const newValue = `${val.slice(0, -1)}
+`;
+          updateValue(newValue, newValue.length);
+          return;
+        }
+        const submitted = val;
+        valueRef.current = "";
+        cursorRef.current = 0;
+        onSubmit?.(submitted);
+        return;
+      }
+      if (key.escape) {
+        return;
+      }
+      if (key.home) {
+        cursorRef.current = 0;
+        setCursor(0);
+        return;
+      }
+      if (key.end) {
+        cursorRef.current = val.length;
+        setCursor(val.length);
+        return;
+      }
+      if (key.leftArrow) {
+        if (key.ctrl || key.meta) {
+          const nc = findPrevWordStart(val, cur);
+          cursorRef.current = nc;
+          setCursor(nc);
+        } else {
+          const nc = Math.max(0, cur - 1);
+          cursorRef.current = nc;
+          setCursor(nc);
+        }
+        return;
+      }
+      if (key.rightArrow) {
+        if (key.ctrl || key.meta) {
+          const nc = findNextWordEnd(val, cur);
+          cursorRef.current = nc;
+          setCursor(nc);
+        } else {
+          const nc = Math.min(val.length, cur + 1);
+          cursorRef.current = nc;
+          setCursor(nc);
+        }
+        return;
+      }
+      if (key.ctrl && input === "a") {
+        cursorRef.current = 0;
+        setCursor(0);
+        return;
+      }
+      if (key.ctrl && input === "e") {
+        cursorRef.current = val.length;
+        setCursor(val.length);
+        return;
+      }
+      if (key.meta && input === "b") {
+        const nc = findPrevWordStart(val, cur);
+        cursorRef.current = nc;
+        setCursor(nc);
+        return;
+      }
+      if (key.meta && input === "f") {
+        const nc = findNextWordEnd(val, cur);
+        cursorRef.current = nc;
+        setCursor(nc);
+        return;
+      }
+      const rawInput = lastRawInputRef.current;
+      if (rawInput === "\x1B[3~" || rawInput.startsWith("\x1B[3~")) {
+        if (cur < val.length) {
+          const newValue = val.slice(0, cur) + val.slice(cur + 1);
+          updateValue(newValue, cur);
+        }
+        return;
+      }
+      const isBackspace = key.backspace || rawInput === "\x7F" || rawInput === "\b" || input === "\x7F" || input === "\b";
+      if (isBackspace) {
+        if (cur > 0) {
+          const newValue = val.slice(0, cur - 1) + val.slice(cur);
+          updateValue(newValue, cur - 1);
+        }
+        return;
+      }
+      if (key.ctrl && input === "w") {
+        const wordStart = findPrevWordStart(val, cur);
+        const newValue = val.slice(0, wordStart) + val.slice(cur);
+        updateValue(newValue, wordStart);
+        return;
+      }
+      if (key.ctrl && input === "u") {
+        const newValue = val.slice(cur);
+        updateValue(newValue, 0);
+        return;
+      }
+      if (key.ctrl && input === "k") {
+        const newValue = val.slice(0, cur);
+        updateValue(newValue, cur);
+        return;
+      }
+      if (key.ctrl && input === "h") {
+        if (cur > 0) {
+          const newValue = val.slice(0, cur - 1) + val.slice(cur);
+          updateValue(newValue, cur - 1);
+        }
+        return;
+      }
+      if (key.tab) {
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        if (input.includes("\n") || input.includes("\r")) {
+          const fullText = val.slice(0, cur) + input + val.slice(cur);
+          const parts = fullText.split(/\r\n|\r|\n/);
+          const toSubmit = parts.map((l) => l.trim()).filter(Boolean);
+          if (toSubmit.length > 0) {
+            valueRef.current = "";
+            cursorRef.current = 0;
+            for (const line of toSubmit) {
+              onSubmit?.(line);
+            }
+            return;
+          }
+          updateValue("", 0);
+          return;
+        }
+        const newValue = val.slice(0, cur) + input + val.slice(cur);
+        updateValue(newValue, cur + input.length);
+      }
+    },
+    { isActive: isFocused && !isDisabled }
+  );
+  const showPlaceholder = value.length === 0;
+  const isMultiline = value.includes("\n");
+  if (showPlaceholder) {
+    return /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { inverse: true }, " "), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, placeholder));
+  }
+  if (isMultiline) {
+    const lines = value.split("\n");
+    let charsSoFar = 0;
+    return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, lines.map((line, lineIdx) => {
+      const lineStart = charsSoFar;
+      charsSoFar += line.length + 1;
+      const cursorInThisLine = cursor >= lineStart && cursor < lineStart + line.length + 1;
+      if (!cursorInThisLine) {
+        return /* @__PURE__ */ React4.createElement(Text4, { key: lineIdx }, lineIdx > 0 && /* @__PURE__ */ React4.createElement(Text4, { color: "gray" }, "... "), line);
+      }
+      const cursorInLine = cursor - lineStart;
+      const before2 = line.slice(0, cursorInLine);
+      const at2 = line[cursorInLine] ?? " ";
+      const after2 = line.slice(cursorInLine + 1);
+      return /* @__PURE__ */ React4.createElement(Text4, { key: lineIdx }, lineIdx > 0 && /* @__PURE__ */ React4.createElement(Text4, { color: "gray" }, "... "), before2, /* @__PURE__ */ React4.createElement(Text4, { inverse: true }, at2), after2);
+    }));
+  }
+  const termWidth = (stdout?.columns ?? 80) - 4;
+  const len = value.length;
+  if (len <= termWidth) {
+    const beforeCursor = value.slice(0, cursor);
+    const atCursor = value[cursor] ?? " ";
+    const afterCursor = value.slice(cursor + 1);
+    return /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, null, beforeCursor), /* @__PURE__ */ React4.createElement(Text4, { inverse: true }, atCursor), /* @__PURE__ */ React4.createElement(Text4, null, afterCursor));
+  }
+  const ellipsis = "\u2026";
+  const usable = termWidth - 2;
+  let windowStart = cursor - Math.floor(usable / 2);
+  if (windowStart < 0) windowStart = 0;
+  if (windowStart + usable > len) windowStart = Math.max(0, len - usable);
+  const windowEnd = Math.min(windowStart + usable, len);
+  const showLeftEllipsis = windowStart > 0;
+  const showRightEllipsis = windowEnd < len;
+  const visibleText = value.slice(windowStart, windowEnd);
+  const cursorInWindow = cursor - windowStart;
+  const before = visibleText.slice(0, cursorInWindow);
+  const at = visibleText[cursorInWindow] ?? " ";
+  const after = visibleText.slice(cursorInWindow + 1);
+  return /* @__PURE__ */ React4.createElement(Box4, null, showLeftEllipsis && /* @__PURE__ */ React4.createElement(Text4, { color: "gray" }, ellipsis), /* @__PURE__ */ React4.createElement(Text4, null, before), /* @__PURE__ */ React4.createElement(Text4, { inverse: true }, at), /* @__PURE__ */ React4.createElement(Text4, null, after), showRightEllipsis && /* @__PURE__ */ React4.createElement(Text4, { color: "gray" }, ellipsis));
+}
+
+// src/repl/components/InputPrompt.tsx
+function InputPrompt({
+  onSubmit,
+  mode,
+  resetKey = 0,
+  history,
+  onInputChange,
+  selectedCompletion,
+  onCompletionAccepted,
+  applyCompletion
+}) {
+  const promptSymbol = mode === "natural" ? ">" : "sql>";
+  const promptColor = mode === "natural" ? "green" : "yellow";
+  const [currentInput, setCurrentInput] = useState2("");
+  const [historyKey, setHistoryKey] = useState2(0);
+  const [historyValue, setHistoryValue] = useState2(
+    void 0
+  );
+  const [searchMode, setSearchMode] = useState2(false);
+  const [searchQuery, setSearchQuery] = useState2("");
+  const [searchMatchIndex, setSearchMatchIndex] = useState2(0);
+  const searchMatches = useMemo(() => {
+    if (!history || !searchQuery) return [];
+    return history.reverseSearch(searchQuery);
+  }, [history, searchQuery]);
+  const currentMatch = searchMatches[searchMatchIndex] ?? "";
+  useEffect2(() => {
+    setCurrentInput("");
+    setHistoryValue(void 0);
+    setHistoryKey((k) => k + 1);
+    setSearchMode(false);
+    setSearchQuery("");
+    setSearchMatchIndex(0);
+    history?.resetIndex();
+  }, [resetKey, history]);
+  useInput2((input, key) => {
+    if (!history) return;
+    if (key.ctrl && input === "r") {
+      if (searchMode) {
+        if (searchMatches.length > 0) {
+          setSearchMatchIndex((i) => (i + 1) % searchMatches.length);
+        }
+      } else {
+        setSearchMode(true);
+        setSearchQuery("");
+        setSearchMatchIndex(0);
+      }
+      return;
+    }
+    if (searchMode) {
+      if (key.escape) {
+        setSearchMode(false);
+        setSearchQuery("");
+        setSearchMatchIndex(0);
+        return;
+      }
+      if (key.return) {
+        if (currentMatch) {
+          setHistoryValue(currentMatch);
+          setHistoryKey((k) => k + 1);
+          setCurrentInput(currentMatch);
+          onInputChange?.(currentMatch);
+        }
+        setSearchMode(false);
+        setSearchQuery("");
+        setSearchMatchIndex(0);
+        return;
+      }
+      return;
+    }
+    if (key.upArrow) {
+      const prev = history.previous(currentInput);
+      if (prev !== void 0) {
+        setHistoryValue(prev);
+        setHistoryKey((k) => k + 1);
+      }
+    } else if (key.downArrow) {
+      const next = history.next();
+      if (next !== void 0) {
+        setHistoryValue(next);
+        setHistoryKey((k) => k + 1);
+      }
+    }
+  });
+  const handleSubmit = useCallback(
+    (value) => {
+      if (selectedCompletion) {
+        const newValue = applyCompletion ? applyCompletion(value, selectedCompletion) : selectedCompletion;
+        setHistoryValue(newValue);
+        setHistoryKey((k) => k + 1);
+        setCurrentInput(newValue);
+        onInputChange?.(newValue);
+        onCompletionAccepted?.();
+        return;
+      }
+      if (history && value.trim()) {
+        history.add(value);
+      }
+      setCurrentInput("");
+      setHistoryValue(void 0);
+      onSubmit(value);
+    },
+    [
+      history,
+      onSubmit,
+      selectedCompletion,
+      onCompletionAccepted,
+      onInputChange,
+      applyCompletion
+    ]
+  );
+  const handleChange = useCallback(
+    (value) => {
+      setCurrentInput(value);
+      onInputChange?.(value);
+    },
+    [onInputChange]
+  );
+  const combinedKey = `${resetKey}-${historyKey}`;
+  const handleSearchChange = useCallback((value) => {
+    setSearchQuery(value);
+    setSearchMatchIndex(0);
+  }, []);
+  if (searchMode) {
+    return /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column", marginTop: 1 }, currentMatch && /* @__PURE__ */ React5.createElement(Box5, null, /* @__PURE__ */ React5.createElement(Text5, { color: "gray" }, "\u2192 "), /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, currentMatch)), /* @__PURE__ */ React5.createElement(Box5, null, /* @__PURE__ */ React5.createElement(Text5, { color: "magenta", bold: true }, "(reverse-i-search)`"), /* @__PURE__ */ React5.createElement(
+      EnhancedTextInput,
+      {
+        key: `search-${combinedKey}`,
+        defaultValue: searchQuery,
+        onChange: handleSearchChange,
+        placeholder: ""
+      }
+    ), /* @__PURE__ */ React5.createElement(Text5, { color: "magenta", bold: true }, "':"), searchMatches.length > 0 && /* @__PURE__ */ React5.createElement(Text5, { color: "gray" }, " ", "(", searchMatchIndex + 1, "/", searchMatches.length, ")")));
+  }
+  return /* @__PURE__ */ React5.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text5, { color: promptColor, bold: true }, promptSymbol, " "), /* @__PURE__ */ React5.createElement(
+    EnhancedTextInput,
+    {
+      key: combinedKey,
+      defaultValue: historyValue ?? "",
+      onSubmit: handleSubmit,
+      onChange: handleChange,
+      placeholder: mode === "natural" ? "Enter query (e.g., users where active = true) or .help" : "Enter SQL query or .natural to switch mode"
+    }
+  ));
+}
+
+// src/repl/components/InspectionPanel.tsx
+import { Box as Box8, Text as Text8 } from "ink";
+import React8 from "react";
+
+// src/repl/result-formatter.tsx
+import { makeTable } from "@oclif/table";
+import { Box as Box6, Text as Text6 } from "ink";
+import React6 from "react";
+function formatValue(value) {
+  if (value === null) return "NULL";
+  if (value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) return JSON.stringify(value);
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function ExecutionResultDisplay({
+  result
+}) {
+  if (result.error) {
+    return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React6.createElement(Text6, { bold: true, color: "red" }, "\u274C Database Error"), /* @__PURE__ */ React6.createElement(Text6, { color: "red" }, result.error), /* @__PURE__ */ React6.createElement(Text6, { color: "gray", dimColor: true }, "(", result.executionTimeMs, "ms)"));
+  }
+  if (result.rows.length === 0) {
+    return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React6.createElement(Text6, { color: "gray" }, "0 rows (", result.executionTimeMs, "ms)"));
+  }
+  const { columns, rows, rowCount, executionTimeMs, truncated } = result;
+  const tableConfig = config.getTable();
+  const formattedData = rows.map((row) => {
+    const formatted = {};
+    for (const col of columns) {
+      formatted[col] = formatValue(row[col]);
+    }
+    return formatted;
+  });
+  const columnConfig = columns.map((col) => ({
+    key: col,
+    name: col,
+    overflow: tableConfig.overflow
+  }));
+  const headerFormatter = tableConfig.headerFormatter === "none" ? (h) => h : tableConfig.headerFormatter;
+  const tableOutput = makeTable({
+    data: formattedData,
+    columns: columnConfig,
+    borderStyle: tableConfig.borderStyle,
+    headerOptions: {
+      formatter: headerFormatter
+    },
+    padding: tableConfig.padding
+  });
+  return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React6.createElement(Text6, null, tableOutput), /* @__PURE__ */ React6.createElement(Text6, { color: "green" }, rowCount, " row", rowCount !== 1 ? "s" : "", " (", executionTimeMs, "ms)", truncated && /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, " (truncated, showing first 100)")));
+}
+
+// src/repl/components/OutputDisplay.tsx
+import React7 from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+function SqlOutput({
+  sql,
+  params,
+  label = "\u{1F4DD} Generated SQL:"
+}) {
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React7.createElement(Text7, { bold: true, color: "yellow" }, label), /* @__PURE__ */ React7.createElement(Box7, { borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text7, { color: "green" }, sql)), params.length > 0 && /* @__PURE__ */ React7.createElement(Text7, null, /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, "Parameters: "), /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, JSON.stringify(params))));
+}
+function SeparateQueriesOutput({
+  queries
+}) {
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", marginY: 1 }, queries.map((q, i) => /* @__PURE__ */ React7.createElement(Box7, { key: i, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Text7, { bold: true, color: "cyan" }, "\u{1F4CE} Separate Query (", q.relation, "):"), /* @__PURE__ */ React7.createElement(
+    Box7,
+    {
+      borderStyle: "single",
+      borderColor: "cyan",
+      paddingX: 1,
+      marginTop: 1
+    },
+    /* @__PURE__ */ React7.createElement(Text7, { color: "green" }, q.sql)
+  ), q.params.length > 0 && /* @__PURE__ */ React7.createElement(Text7, null, /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, "Parameters: "), /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, JSON.stringify(q.params))))));
+}
+function PlanOutput({
+  plan,
+  verbosity = "normal"
+}) {
+  const hasDecisions = plan.decisions.length > 0;
+  const hasWarnings = plan.warnings.length > 0;
+  const hasCtes = plan.cteCount > 0;
+  if (verbosity === "compact" || !hasDecisions && !hasCtes && !hasWarnings) {
+    return /* @__PURE__ */ React7.createElement(Box7, { marginY: 1 }, /* @__PURE__ */ React7.createElement(Text7, { bold: true, color: "magenta" }, "\u{1F4CB} Plan:", " "), /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, plan.rootTable || plan.strategy, hasDecisions ? ` (${plan.decisions.length} decision${plan.decisions.length > 1 ? "s" : ""}${hasWarnings ? `, ${plan.warnings.length} warning${plan.warnings.length > 1 ? "s" : ""}` : ""})` : " (no decisions)"), plan.planningTimeMs > 0 && /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, " \u23F1 ", plan.planningTimeMs.toFixed(1), "ms"));
+  }
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React7.createElement(Text7, { bold: true, color: "magenta" }, "\u{1F4CB} Query Plan:"), /* @__PURE__ */ React7.createElement(Box7, { paddingLeft: 2, flexDirection: "column" }, plan.rootTable && /* @__PURE__ */ React7.createElement(Text7, null, "Root: ", /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, plan.rootTable)), plan.tables.length > 0 && /* @__PURE__ */ React7.createElement(Text7, null, "Tables: ", /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, plan.tables.join(", "))), hasDecisions && /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text7, { bold: true }, "Decisions:"), plan.decisions.map((d, i) => /* @__PURE__ */ React7.createElement(Box7, { key: i, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text7, null, /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, " \u2022 "), /* @__PURE__ */ React7.createElement(Text7, { color: "blue" }, d.type), /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, ": "), /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, d.context), /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, " \u2014 "), /* @__PURE__ */ React7.createElement(Text7, { color: "green" }, d.choice), /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, " (", d.reasoning, ")")), verbosity === "verbose" && /* @__PURE__ */ React7.createElement(Box7, { paddingLeft: 4, flexDirection: "column" }, d.alternatives && d.alternatives.length > 0 && /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, "\u251C Alternatives: ", d.alternatives.join(", ")), d.foreignKey && /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, "\u251C FK:", " ", Array.isArray(d.foreignKey) ? d.foreignKey.join(", ") : d.foreignKey), d.relationType && /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, "\u251C Relation: ", d.relationType), (d.intentPath || d.relationPath) && /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, "\u2514 Path: ", d.intentPath ?? d.relationPath))))), verbosity === "verbose" && plan.ctes && plan.ctes.length > 0 ? /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text7, { bold: true }, "CTEs:"), plan.ctes.map((c, i) => /* @__PURE__ */ React7.createElement(Box7, { key: i, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text7, null, /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, " \u2022 "), /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, c.name), /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, " ", "\u2014 ", c.purpose, c.recursive ? " (recursive)" : "")), c.referencedBy && c.referencedBy.length > 0 && /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, "   \u2514 Referenced by: ", c.referencedBy.join(", "))))) : hasCtes && /* @__PURE__ */ React7.createElement(Text7, null, "CTEs: ", /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, plan.cteCount, " extracted")), hasWarnings && /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text7, { color: "yellow" }, "\u26A0\uFE0F Warnings:"), plan.warnings.map((w, i) => /* @__PURE__ */ React7.createElement(Box7, { key: i, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text7, { color: "yellow" }, " ", "\u2022 ", w.code ? `${w.code}: ` : "", w.message), w.suggestion && /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, " \u2192 ", w.suggestion), verbosity === "verbose" && w.relatedDecision && /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, " ", "\u2514 Related decision: ", w.relatedDecision)))), verbosity === "verbose" && plan.metadata && /* @__PURE__ */ React7.createElement(Text7, { color: "gray", dimColor: true }, "\u{1F4CA} Metadata: ", plan.metadata.relationsAnalyzed, " relation", plan.metadata.relationsAnalyzed !== 1 ? "s" : "", " analyzed", plan.metadata.isAmbiguous ? ` | ambiguous (${plan.metadata.ambiguousOptions?.join(", ")})` : " | not ambiguous"), plan.planningTimeMs > 0 && /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, "\u23F1 Planning: ", plan.planningTimeMs.toFixed(1), "ms")));
+}
+function ErrorOutput({ message }) {
+  return /* @__PURE__ */ React7.createElement(Box7, { marginY: 1 }, /* @__PURE__ */ React7.createElement(Text7, { color: "red" }, "\u274C Error: ", message));
+}
+function formatParseTree(parsed) {
+  const lines = [];
+  const formatValue2 = (value, indent = 2) => {
+    const pad = " ".repeat(indent);
+    if (value === null) return "null";
+    if (value === void 0) return "undefined";
+    if (typeof value === "string") return `"${value}"`;
+    if (typeof value === "number" || typeof value === "boolean")
+      return String(value);
+    if (Array.isArray(value)) {
+      if (value.length === 0) return "[]";
+      const items = value.map((v) => formatValue2(v, indent + 2)).join(", ");
+      return `[${items}]`;
+    }
+    if (typeof value === "object") {
+      const entries = Object.entries(value);
+      if (entries.length === 0) return "{}";
+      const formatted = entries.map(([k, v]) => `${pad}  ${k}: ${formatValue2(v, indent + 2)}`).join("\n");
+      return `{
+${formatted}
+${pad}}`;
+    }
+    return String(value);
+  };
+  lines.push("ParsedQuery {");
+  const obj = parsed;
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      lines.push(`  ${key}: ${formatValue2(value)}`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function ParseTreeOutput({ parsed }) {
+  const treeText = formatParseTree(parsed);
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React7.createElement(Text7, { bold: true, color: "blue" }, "\u{1F333} Parse Tree (AST):"), /* @__PURE__ */ React7.createElement(Box7, { borderStyle: "single", borderColor: "blue", paddingX: 1, marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text7, { color: "white" }, treeText)));
+}
+function OutputDisplay({ result, planVerbosity }) {
+  if (!result) return null;
+  if (result.error) {
+    return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column" }, /* @__PURE__ */ React7.createElement(ErrorOutput, { message: result.error }), result.parsedQuery !== void 0 && /* @__PURE__ */ React7.createElement(ParseTreeOutput, { parsed: result.parsedQuery }));
+  }
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column" }, result.parsedQuery !== void 0 && /* @__PURE__ */ React7.createElement(ParseTreeOutput, { parsed: result.parsedQuery }), /* @__PURE__ */ React7.createElement(SqlOutput, { sql: result.sql, params: result.params, label: "\u{1F4DD} Main SQL:" }), result.separateQueries && result.separateQueries.length > 0 && /* @__PURE__ */ React7.createElement(SeparateQueriesOutput, { queries: result.separateQueries }), result.plan && /* @__PURE__ */ React7.createElement(PlanOutput, { plan: result.plan, verbosity: planVerbosity ?? "normal" }));
+}
+
+// src/repl/components/InspectionPanel.tsx
+var ALL_VIEWS = ["sql", "plan", "results", "params", "dump"];
+var TAB_LABELS = {
+  sql: "SQL",
+  plan: "Plan",
+  results: "Results",
+  params: "Params",
+  dump: "Dump"
+};
+function TabBar({
+  activeView,
+  execMode
+}) {
+  return /* @__PURE__ */ React8.createElement(Box8, null, ALL_VIEWS.map((v, i) => {
+    const isActive = v === activeView;
+    const isDimmed = v === "results" && !execMode;
+    return /* @__PURE__ */ React8.createElement(React8.Fragment, { key: v }, i > 0 && /* @__PURE__ */ React8.createElement(Text8, { color: "gray" }, " "), isActive ? /* @__PURE__ */ React8.createElement(Text8, { bold: true, inverse: true, color: "blue" }, ` ${TAB_LABELS[v]} `) : /* @__PURE__ */ React8.createElement(Text8, { color: isDimmed ? "gray" : "white", dimColor: isDimmed }, ` ${TAB_LABELS[v]} `));
+  }), /* @__PURE__ */ React8.createElement(Text8, { color: "gray" }, " Tab\u21B9 cycle \xB7 Esc close"));
+}
+function PanelContent({
+  view,
+  queryResult,
+  executionResult,
+  execMode
+}) {
+  if (!queryResult && !executionResult) {
+    return /* @__PURE__ */ React8.createElement(Text8, { color: "gray" }, "No query result to inspect.");
+  }
+  switch (view) {
+    case "sql": {
+      if (!queryResult) return /* @__PURE__ */ React8.createElement(Text8, { color: "gray" }, "No SQL available.");
+      return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column" }, /* @__PURE__ */ React8.createElement(
+        SqlOutput,
+        {
+          sql: queryResult.sql,
+          params: queryResult.params,
+          label: "Main SQL:"
+        }
+      ), queryResult.separateQueries && queryResult.separateQueries.length > 0 && /* @__PURE__ */ React8.createElement(SeparateQueriesOutput, { queries: queryResult.separateQueries }));
+    }
+    case "plan": {
+      if (!queryResult?.plan)
+        return /* @__PURE__ */ React8.createElement(Text8, { color: "gray" }, "No query plan available.");
+      return /* @__PURE__ */ React8.createElement(PlanOutput, { plan: queryResult.plan, verbosity: "verbose" });
+    }
+    case "results": {
+      if (!execMode)
+        return /* @__PURE__ */ React8.createElement(Text8, { color: "gray" }, "Not in execution mode. Use .exec to enable.");
+      if (!executionResult)
+        return /* @__PURE__ */ React8.createElement(Text8, { color: "gray" }, "No execution results yet. Run a query with .exec enabled.");
+      return /* @__PURE__ */ React8.createElement(ExecutionResultDisplay, { result: executionResult });
+    }
+    case "params": {
+      if (!queryResult)
+        return /* @__PURE__ */ React8.createElement(Text8, { color: "gray" }, "No parameters available.");
+      const params = queryResult.params;
+      if (params.length === 0) {
+        return /* @__PURE__ */ React8.createElement(Text8, { color: "gray" }, "No parameters (static query).");
+      }
+      return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column" }, params.map((p, i) => /* @__PURE__ */ React8.createElement(Text8, { key: i }, /* @__PURE__ */ React8.createElement(Text8, { color: "cyan" }, "$", i + 1), /* @__PURE__ */ React8.createElement(Text8, { color: "gray" }, " = "), /* @__PURE__ */ React8.createElement(Text8, { color: "green" }, JSON.stringify(p)))));
+    }
+    case "dump": {
+      return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column" }, queryResult && /* @__PURE__ */ React8.createElement(React8.Fragment, null, /* @__PURE__ */ React8.createElement(
+        SqlOutput,
+        {
+          sql: queryResult.sql,
+          params: queryResult.params,
+          label: "Main SQL:"
+        }
+      ), queryResult.separateQueries && queryResult.separateQueries.length > 0 && /* @__PURE__ */ React8.createElement(
+        SeparateQueriesOutput,
+        {
+          queries: queryResult.separateQueries
+        }
+      ), queryResult.plan && /* @__PURE__ */ React8.createElement(PlanOutput, { plan: queryResult.plan, verbosity: "verbose" }), queryResult.parsedQuery !== void 0 && /* @__PURE__ */ React8.createElement(ParseTreeOutput, { parsed: queryResult.parsedQuery })), executionResult && /* @__PURE__ */ React8.createElement(ExecutionResultDisplay, { result: executionResult }));
+    }
+  }
+}
+function InspectionPanel(props) {
+  return /* @__PURE__ */ React8.createElement(
+    Box8,
+    {
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor: "blue",
+      paddingX: 1,
+      marginTop: 1
+    },
+    /* @__PURE__ */ React8.createElement(TabBar, { activeView: props.view, execMode: props.execMode }),
+    /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React8.createElement(PanelContent, { ...props }))
+  );
+}
+
+// src/repl/conversation/ConversationView.tsx
+import { Box as Box9, Text as Text9 } from "ink";
+import React9 from "react";
+function QuerySummary({
+  queryResult,
+  execResult
+}) {
+  if (!queryResult && !execResult) return null;
+  const parts = [];
+  if (execResult) {
+    if (execResult.error) {
+      return /* @__PURE__ */ React9.createElement(Text9, { color: "red" }, "\u2717 ", execResult.error);
+    }
+    parts.push(
+      `${execResult.rowCount} row${execResult.rowCount !== 1 ? "s" : ""}`
+    );
+    parts.push(`${execResult.executionTimeMs.toFixed(0)}ms`);
+    if (execResult.truncated) parts.push("truncated");
+  }
+  if (queryResult) {
+    if (queryResult.error) {
+      return /* @__PURE__ */ React9.createElement(Text9, { color: "red" }, "\u2717 ", queryResult.error);
+    }
+    if (!execResult) {
+      const plan = queryResult.plan;
+      if (plan?.rootTable) parts.push(plan.rootTable);
+      if (plan && plan.cteCount > 0)
+        parts.push(`${plan.cteCount} CTE${plan.cteCount !== 1 ? "s" : ""}`);
+      if (queryResult.separateQueries && queryResult.separateQueries.length > 0) {
+        parts.push(
+          `+${queryResult.separateQueries.length} quer${queryResult.separateQueries.length !== 1 ? "ies" : "y"}`
+        );
+      }
+      if (plan && plan.planningTimeMs > 0)
+        parts.push(`${plan.planningTimeMs.toFixed(1)}ms`);
+      if (plan?.warnings && plan.warnings.length > 0)
+        parts.push(
+          `${plan.warnings.length} warning${plan.warnings.length !== 1 ? "s" : ""}`
+        );
+    }
+  }
+  return /* @__PURE__ */ React9.createElement(Text9, null, /* @__PURE__ */ React9.createElement(Text9, { color: "green" }, "\u2713 "), /* @__PURE__ */ React9.createElement(Text9, { color: "gray" }, parts.join(" \xB7 ")));
+}
+function ConversationEntryView({
+  entry,
+  outputLayout,
+  planVerbosity
+}) {
+  let queryResult = null;
+  let execResult = null;
+  let infoMessage = null;
+  let errorMessage = null;
+  for (const event of entry.events) {
+    switch (event.type) {
+      case "query-result":
+        queryResult = event.result;
+        break;
+      case "execution-result":
+        execResult = event.result;
+        break;
+      case "info":
+        infoMessage = event.message;
+        break;
+      case "error":
+        errorMessage = event.message;
+        break;
+    }
+  }
+  const hasQueryOutput = queryResult !== null || execResult !== null;
+  return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", marginBottom: 1 }, entry.input && /* @__PURE__ */ React9.createElement(Text9, null, /* @__PURE__ */ React9.createElement(Text9, { color: "blue", bold: true }, "\u276F "), /* @__PURE__ */ React9.createElement(Text9, { bold: true }, entry.input)), infoMessage && /* @__PURE__ */ React9.createElement(Text9, null, infoMessage), errorMessage && /* @__PURE__ */ React9.createElement(Text9, { color: "red" }, errorMessage), hasQueryOutput && outputLayout === "compact" && /* @__PURE__ */ React9.createElement(QuerySummary, { queryResult, execResult }), hasQueryOutput && outputLayout === "sql" && /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column" }, /* @__PURE__ */ React9.createElement(QuerySummary, { queryResult, execResult }), queryResult && /* @__PURE__ */ React9.createElement(OutputDisplay, { result: queryResult, planVerbosity })), hasQueryOutput && outputLayout === "results" && /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column" }, /* @__PURE__ */ React9.createElement(QuerySummary, { queryResult, execResult }), execResult && /* @__PURE__ */ React9.createElement(ExecutionResultDisplay, { result: execResult })), hasQueryOutput && outputLayout === "full" && /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column" }, queryResult && /* @__PURE__ */ React9.createElement(OutputDisplay, { result: queryResult, planVerbosity }), execResult && /* @__PURE__ */ React9.createElement(ExecutionResultDisplay, { result: execResult })));
+}
+function ConversationView({
+  entries,
+  outputLayout,
+  planVerbosity
+}) {
+  if (entries.length === 0) return null;
+  return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column" }, entries.map((entry) => /* @__PURE__ */ React9.createElement(
+    ConversationEntryView,
+    {
+      key: entry.id,
+      entry,
+      outputLayout,
+      planVerbosity
+    }
+  )));
+}
+
+// src/repl/conversation/conversation-model.ts
+var MAX_ENTRIES = 100;
+var ConversationManager = class {
+  entries = [];
+  nextId = 1;
+  /** Create a new entry for user input. Returns the entry for event appending. */
+  addEntry(input) {
+    const entry = {
+      id: this.nextId++,
+      timestamp: /* @__PURE__ */ new Date(),
+      input,
+      events: []
+    };
+    this.entries.push(entry);
+    if (this.entries.length > MAX_ENTRIES) {
+      this.entries.splice(0, this.entries.length - MAX_ENTRIES);
+    }
+    return entry;
+  }
+  /** Append an event to an existing entry. */
+  appendEvent(entryId, event) {
+    const entry = this.entries.find((e) => e.id === entryId);
+    if (entry) {
+      entry.events.push(event);
+    }
+  }
+  /** Get all entries (readonly). */
+  getEntries() {
+    return this.entries;
+  }
+  /** Clear all entries. */
+  clear() {
+    this.entries = [];
+  }
+};
+
+// src/repl/history.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var HISTORY_FILE = join(homedir(), ".dbsp_history");
+var MAX_HISTORY_SIZE = 1e3;
+function unescapeHistoryLine(line) {
+  let result = "";
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] === "\\" && i + 1 < line.length) {
+      const next = line[i + 1];
+      if (next === "\\") {
+        result += "\\";
+        i++;
+      } else if (next === "n") {
+        result += "\n";
+        i++;
+      } else {
+        result += line[i];
+      }
+    } else {
+      result += line[i];
+    }
+  }
+  return result;
+}
+var CommandHistory = class {
+  history = [];
+  index = -1;
+  currentInput = "";
+  constructor() {
+    this.load();
+  }
+  /**
+   * Load history from file
+   */
+  load() {
+    try {
+      if (existsSync(HISTORY_FILE)) {
+        try {
+          chmodSync(HISTORY_FILE, 384);
+        } catch {
+        }
+        const content = readFileSync(HISTORY_FILE, "utf-8");
+        this.history = content.split("\n").filter((line) => line.trim().length > 0).map((line) => unescapeHistoryLine(line));
+      }
+    } catch {
+    }
+  }
+  /**
+   * Save history to file
+   */
+  save() {
+    try {
+      const dir = dirname(HISTORY_FILE);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      const encoded = this.history.map((entry) => entry.replace(/\\/g, "\\\\").replace(/\n/g, "\\n")).join("\n");
+      writeFileSync(HISTORY_FILE, encoded, {
+        encoding: "utf-8",
+        mode: 384
+      });
+      try {
+        chmodSync(HISTORY_FILE, 384);
+      } catch {
+      }
+    } catch {
+    }
+  }
+  /**
+   * Add a command to history.
+   *
+   * @param command - Command string to record
+   * @param persist - Whether to persist to disk (default: true). Pass false for
+   *   batch-mode queries that should not be saved to ~/.dbsp_history (SEC-13).
+   */
+  add(command, persist = true) {
+    const trimmed = command.trim();
+    if (!trimmed) return;
+    if (this.history[this.history.length - 1] === trimmed) return;
+    this.history.push(trimmed);
+    if (this.history.length > MAX_HISTORY_SIZE) {
+      this.history = this.history.slice(-MAX_HISTORY_SIZE);
+    }
+    this.resetIndex();
+    if (persist) {
+      this.save();
+    }
+  }
+  /**
+   * Reset the navigation index
+   */
+  resetIndex() {
+    this.index = -1;
+    this.currentInput = "";
+  }
+  /**
+   * Navigate to previous command (up arrow)
+   * Returns the command to display, or undefined if at start of history
+   */
+  previous(currentInput) {
+    if (this.index === -1) {
+      this.currentInput = currentInput;
+    }
+    if (this.history.length === 0) return void 0;
+    if (this.index < this.history.length - 1) {
+      this.index++;
+    }
+    return this.history[this.history.length - 1 - this.index];
+  }
+  /**
+   * Navigate to next command (down arrow)
+   * Returns the command to display, or the saved current input if past history
+   */
+  next() {
+    if (this.index <= 0) {
+      this.index = -1;
+      return this.currentInput;
+    }
+    this.index--;
+    return this.history[this.history.length - 1 - this.index];
+  }
+  /**
+   * Search history for commands containing the query
+   */
+  search(query) {
+    if (!query) return this.history.slice(-10);
+    const lower = query.toLowerCase();
+    return this.history.filter((cmd) => cmd.toLowerCase().includes(lower));
+  }
+  /**
+   * CLI-MUT: Reverse incremental search (Ctrl+R functionality)
+   * Returns matches from most recent to oldest
+   */
+  reverseSearch(query) {
+    if (!query) return [];
+    const lower = query.toLowerCase();
+    return this.history.filter((cmd) => cmd.toLowerCase().includes(lower)).reverse();
+  }
+  /**
+   * Get all history entries
+   */
+  getAll() {
+    return this.history;
+  }
+  /**
+   * Get recent history (last N entries)
+   */
+  getRecent(count = 10) {
+    return this.history.slice(-count);
+  }
+  /**
+   * Clear all history
+   */
+  clear() {
+    this.history = [];
+    this.resetIndex();
+    this.save();
+  }
+  /**
+   * Get total count
+   */
+  get length() {
+    return this.history.length;
+  }
+};
+var historyInstance = null;
+function getHistory() {
+  if (!historyInstance) {
+    historyInstance = new CommandHistory();
+  }
+  return historyInstance;
+}
+
+// src/repl/index.tsx
+function ReplApp({ config: config2 }) {
+  const { exit } = useApp();
+  const engineRef = useRef2(null);
+  if (!engineRef.current) {
+    engineRef.current = new ReplEngine({
+      schema: config2.schema,
+      schemaPath: config2.schemaPath,
+      ...config2.databaseUrl !== void 0 && {
+        databaseUrl: config2.databaseUrl
+      },
+      ...config2.initialSchemaName !== void 0 && {
+        initialSchemaName: config2.initialSchemaName
+      },
+      ...config2.initialParseMode !== void 0 && {
+        initialParseMode: config2.initialParseMode
+      },
+      ...config2.initialExecMode !== void 0 && {
+        initialExecMode: config2.initialExecMode
+      },
+      ...config2.dbCasing !== void 0 && { dbCasing: config2.dbCasing }
+    });
+  }
+  const engine = engineRef.current;
+  const conversationRef = useRef2(null);
+  if (!conversationRef.current) {
+    conversationRef.current = new ConversationManager();
+  }
+  const conversation = conversationRef.current;
+  const [engineState, setEngineState] = useState3(
+    engine.getState()
+  );
+  const [entries, setEntries] = useState3(conversation.getEntries());
+  const [showHelp, setShowHelp] = useState3(false);
+  const [inputKey, setInputKey] = useState3(0);
+  const [panelView, setPanelView] = useState3(null);
+  const [lastQueryResult, setLastQueryResult] = useState3(
+    null
+  );
+  const [lastExecResult, setLastExecResult] = useState3(
+    null
+  );
+  const completionProvider = useMemo2(
+    () => engine.getCompletionProvider(),
+    [engine]
+  );
+  const [completions, setCompletions] = useState3([]);
+  const [selectedCompletionIndex, setSelectedCompletionIndex] = useState3(-1);
+  const history = useMemo2(() => getHistory(), []);
+  useEffect3(() => {
+    engine.init();
+    return () => {
+      engine.destroy();
+    };
+  }, [engine]);
+  const currentEntryIdRef = useRef2(null);
+  useEffect3(() => {
+    const refreshEntries = () => setEntries([...conversation.getEntries()]);
+    const appendToCurrentOrCreate = (event) => {
+      if (currentEntryIdRef.current !== null) {
+        conversation.appendEvent(currentEntryIdRef.current, event);
+      } else {
+        const entry = conversation.addEntry("");
+        conversation.appendEvent(entry.id, event);
+      }
+      refreshEntries();
+    };
+    const unsub = engine.on((event) => {
+      switch (event.type) {
+        case "state-change":
+          setEngineState(event.state);
+          break;
+        case "exit":
+          exit();
+          break;
+        case "clear":
+          conversation.clear();
+          setShowHelp(false);
+          setPanelView(null);
+          setLastQueryResult(null);
+          setLastExecResult(null);
+          refreshEntries();
+          break;
+        case "info":
+          if (event.message === "SHOW_HELP") {
+            setShowHelp(true);
+            break;
+          }
+          appendToCurrentOrCreate(event);
+          break;
+        case "error":
+          appendToCurrentOrCreate(event);
+          break;
+        case "query-result":
+          if (currentEntryIdRef.current !== null) {
+            conversation.appendEvent(currentEntryIdRef.current, event);
+            refreshEntries();
+          }
+          setLastQueryResult(event.result);
+          break;
+        case "execution-result":
+          if (currentEntryIdRef.current !== null) {
+            conversation.appendEvent(currentEntryIdRef.current, event);
+            refreshEntries();
+          }
+          setLastExecResult(event.result);
+          setLastQueryResult(event.query);
+          break;
+        case "show-history": {
+          const recent = history.getRecent(20);
+          const msg = recent.length === 0 ? "No command history yet." : `\u{1F4DC} Recent Commands (${recent.length}):
+${recent.map((cmd, i) => `  ${i + 1}. ${cmd}`).join("\n")}`;
+          appendToCurrentOrCreate({ type: "info", message: msg });
+          break;
+        }
+        case "show-panel":
+          setPanelView(event.view);
+          break;
+        case "close-panel":
+          setPanelView(null);
+          break;
+        case "layout-change":
+          break;
+      }
+    });
+    return unsub;
+  }, [engine, conversation, exit]);
+  useInput3((inputChar, key) => {
+    if (key.ctrl && inputChar === "c") {
+      exit();
+    }
+    if (key.escape && panelView !== null) {
+      setPanelView(null);
+      return;
+    }
+    if (key.tab) {
+      if (panelView !== null) {
+        const views = ["sql", "plan", "results", "params", "dump"];
+        const currentIdx = views.indexOf(panelView);
+        const nextIdx = (currentIdx + 1) % views.length;
+        const nextView = views[nextIdx];
+        if (nextView) setPanelView(nextView);
+        return;
+      }
+      if (completions.length > 0 && engineState.mode === "natural") {
+        const nextIndex = selectedCompletionIndex < 0 ? 0 : (selectedCompletionIndex + 1) % completions.length;
+        setSelectedCompletionIndex(nextIndex);
+      }
+    }
+  });
+  const handleInputChange = useCallback2(
+    (value) => {
+      setSelectedCompletionIndex(-1);
+      if (engineState.mode === "natural") {
+        const suggestions = completionProvider.complete(value);
+        setCompletions(suggestions);
+      } else {
+        setCompletions([]);
+      }
+    },
+    [completionProvider, engineState.mode]
+  );
+  const handleCompletionAccepted = useCallback2(() => {
+    setSelectedCompletionIndex(-1);
+    setCompletions([]);
+  }, []);
+  const handleApplyCompletion = useCallback2(
+    (currentInput, completionText) => {
+      return completionProvider.applyCompletion(currentInput, completionText);
+    },
+    [completionProvider]
+  );
+  const selectedCompletion = selectedCompletionIndex >= 0 ? completions[selectedCompletionIndex]?.text : void 0;
+  const submitQueueRef = useRef2([]);
+  const isProcessingRef = useRef2(false);
+  const processQueue = useCallback2(async () => {
+    if (isProcessingRef.current) return;
+    isProcessingRef.current = true;
+    while (submitQueueRef.current.length > 0) {
+      const trimmed = submitQueueRef.current.shift();
+      if (trimmed === void 0) break;
+      history.add(trimmed);
+      const entry = conversation.addEntry(trimmed);
+      currentEntryIdRef.current = entry.id;
+      setEntries([...conversation.getEntries()]);
+      await engine.submit(trimmed);
+      currentEntryIdRef.current = null;
+    }
+    isProcessingRef.current = false;
+  }, [engine, conversation, history]);
+  const handleSubmit = useCallback2(
+    (value) => {
+      const trimmed = value.trim();
+      if (!trimmed) return;
+      setInputKey((k) => k + 1);
+      setCompletions([]);
+      setShowHelp(false);
+      submitQueueRef.current.push(trimmed);
+      processQueue();
+    },
+    [processQueue]
+  );
+  const tableCount = config2.schema.tableNames.length;
+  const relationCount = config2.schema.model.relations.size;
+  const contentArea = /* @__PURE__ */ React10.createElement(Box10, { flexDirection: "column" }, showHelp && /* @__PURE__ */ React10.createElement(HelpDisplay, null), /* @__PURE__ */ React10.createElement(
+    ConversationView,
+    {
+      entries,
+      outputLayout: engineState.outputLayout,
+      planVerbosity: engineState.planVerbosity
+    }
+  ), engineState.mode === "natural" && completions.length > 0 && !showHelp && /* @__PURE__ */ React10.createElement(
+    CompletionDisplay,
+    {
+      suggestions: completions,
+      selectedIndex: selectedCompletionIndex
+    }
+  ), /* @__PURE__ */ React10.createElement(
+    InputPrompt,
+    {
+      onSubmit: handleSubmit,
+      mode: engineState.mode,
+      resetKey: inputKey,
+      history,
+      onInputChange: handleInputChange,
+      ...selectedCompletion !== void 0 && { selectedCompletion },
+      onCompletionAccepted: handleCompletionAccepted,
+      applyCompletion: handleApplyCompletion
+    }
+  ), panelView !== null && /* @__PURE__ */ React10.createElement(
+    InspectionPanel,
+    {
+      view: panelView,
+      queryResult: lastQueryResult,
+      executionResult: lastExecResult,
+      execMode: engineState.execMode,
+      onViewChange: setPanelView
+    }
+  ));
+  return /* @__PURE__ */ React10.createElement(Box10, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React10.createElement(
+    Header,
+    {
+      schemaPath: config2.schemaPath,
+      mode: engineState.mode,
+      tableCount,
+      relationCount,
+      dialect: engineState.dialect,
+      includeStrategy: engineState.includeStrategy,
+      aliasingMode: engineState.aliasingMode,
+      connected: engineState.connected,
+      execMode: engineState.execMode,
+      parseMode: engineState.parseMode,
+      explainMode: engineState.explainMode,
+      ...engineState.schemaName && { schemaName: engineState.schemaName },
+      ...config2.databaseUrl && {
+        databaseName: getDatabaseName(config2.databaseUrl)
+      }
+    }
+  ), contentArea);
+}
+async function startRepl(config2) {
+  console.log("Starting REPL...\n");
+  const instance = render(/* @__PURE__ */ React10.createElement(ReplApp, { config: config2 }));
+  await instance.waitUntilExit();
+}
+export {
+  startRepl
+};
+//# sourceMappingURL=repl-4OFERLKZ.js.map