@reifydb/shell 0.2.0

package/dist/index.js

@@ -0,0 +1,1137 @@
+// src/terminal/adapter.ts
+import { Terminal } from "@xterm/xterm";
+import { FitAddon } from "@xterm/addon-fit";
+import "@xterm/xterm/css/xterm.css";
+
+// src/terminal/theme.ts
+var defaultTheme = {
+  background: "#1e1e2e",
+  foreground: "#cdd6f4",
+  cursor: "#f5e0dc",
+  cursorAccent: "#1e1e2e",
+  selectionBackground: "#45475a",
+  black: "#45475a",
+  red: "#f38ba8",
+  green: "#a6e3a1",
+  yellow: "#f9e2af",
+  blue: "#89b4fa",
+  magenta: "#f5c2e7",
+  cyan: "#94e2d5",
+  white: "#bac2de",
+  brightBlack: "#585b70",
+  brightRed: "#f38ba8",
+  brightGreen: "#a6e3a1",
+  brightYellow: "#f9e2af",
+  brightBlue: "#89b4fa",
+  brightMagenta: "#f5c2e7",
+  brightCyan: "#94e2d5",
+  brightWhite: "#a6adc8"
+};
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m",
+  // Foreground colors
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  // Bright foreground colors
+  brightBlack: "\x1B[90m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m",
+  brightWhite: "\x1B[97m"
+};
+
+// src/terminal/adapter.ts
+var TerminalAdapter = class {
+  terminal;
+  fitAddon;
+  keyHandler = null;
+  resizeObserver = null;
+  constructor(container, theme = defaultTheme) {
+    this.terminal = new Terminal({
+      theme,
+      fontFamily: "'JetBrains Mono', 'Fira Code', 'Consolas', 'Monaco', monospace",
+      fontSize: 14,
+      lineHeight: 1.2,
+      cursorBlink: true,
+      cursorStyle: "block",
+      scrollback: 1e4,
+      allowProposedApi: true
+    });
+    this.fitAddon = new FitAddon();
+    this.terminal.loadAddon(this.fitAddon);
+    container.innerHTML = "";
+    this.terminal.open(container);
+    this.fitAddon.fit();
+    this.resizeObserver = new ResizeObserver(() => {
+      this.fitAddon.fit();
+    });
+    this.resizeObserver.observe(container);
+    this.terminal.onKey(({ key, domEvent }) => {
+      if (this.keyHandler) {
+        this.keyHandler(key, domEvent);
+      }
+    });
+  }
+  onKey(handler) {
+    this.keyHandler = handler;
+  }
+  write(text) {
+    this.terminal.write(text);
+  }
+  writeln(text) {
+    this.terminal.writeln(text);
+  }
+  clear() {
+    this.terminal.clear();
+  }
+  get cols() {
+    return this.terminal.cols;
+  }
+  get rows() {
+    return this.terminal.rows;
+  }
+  focus() {
+    this.terminal.focus();
+  }
+  dispose() {
+    if (this.resizeObserver) {
+      this.resizeObserver.disconnect();
+      this.resizeObserver = null;
+    }
+    this.terminal.dispose();
+  }
+  // ANSI escape code helpers - static for use without instance
+  static COLORS = COLORS;
+  // Cursor control helpers
+  static cursorUp(n = 1) {
+    return `\x1B[${n}A`;
+  }
+  static cursorDown(n = 1) {
+    return `\x1B[${n}B`;
+  }
+  static cursorForward(n = 1) {
+    return `\x1B[${n}C`;
+  }
+  static cursorBack(n = 1) {
+    return `\x1B[${n}D`;
+  }
+  static cursorPosition(row, col) {
+    return `\x1B[${row};${col}H`;
+  }
+  static clearLine() {
+    return "\x1B[2K";
+  }
+  static clearToEndOfLine() {
+    return "\x1B[K";
+  }
+  static clearScreen() {
+    return "\x1B[2J\x1B[3J\x1B[H";
+  }
+  static saveCursor() {
+    return "\x1B[s";
+  }
+  static restoreCursor() {
+    return "\x1B[u";
+  }
+};
+
+// src/input/line-editor.ts
+var LineEditor = class {
+  buffer = "";
+  cursorPos = 0;
+  terminal;
+  constructor(terminal) {
+    this.terminal = terminal;
+  }
+  get value() {
+    return this.buffer;
+  }
+  get cursor() {
+    return this.cursorPos;
+  }
+  clear() {
+    this.buffer = "";
+    this.cursorPos = 0;
+  }
+  setValue(value) {
+    this.buffer = value;
+    this.cursorPos = value.length;
+  }
+  insert(char) {
+    this.buffer = this.buffer.slice(0, this.cursorPos) + char + this.buffer.slice(this.cursorPos);
+    this.cursorPos++;
+  }
+  backspace() {
+    if (this.cursorPos > 0) {
+      this.buffer = this.buffer.slice(0, this.cursorPos - 1) + this.buffer.slice(this.cursorPos);
+      this.cursorPos--;
+      return true;
+    }
+    return false;
+  }
+  delete() {
+    if (this.cursorPos < this.buffer.length) {
+      this.buffer = this.buffer.slice(0, this.cursorPos) + this.buffer.slice(this.cursorPos + 1);
+      return true;
+    }
+    return false;
+  }
+  moveLeft() {
+    if (this.cursorPos > 0) {
+      this.cursorPos--;
+      this.terminal.write(TerminalAdapter.cursorBack());
+      return true;
+    }
+    return false;
+  }
+  moveRight() {
+    if (this.cursorPos < this.buffer.length) {
+      this.cursorPos++;
+      this.terminal.write(TerminalAdapter.cursorForward());
+      return true;
+    }
+    return false;
+  }
+  moveToStart() {
+    if (this.cursorPos > 0) {
+      this.terminal.write(TerminalAdapter.cursorBack(this.cursorPos));
+      this.cursorPos = 0;
+    }
+  }
+  moveToEnd() {
+    if (this.cursorPos < this.buffer.length) {
+      const distance = this.buffer.length - this.cursorPos;
+      this.terminal.write(TerminalAdapter.cursorForward(distance));
+      this.cursorPos = this.buffer.length;
+    }
+  }
+  moveWordLeft() {
+    if (this.cursorPos === 0) return;
+    let newPos = this.cursorPos - 1;
+    while (newPos > 0 && /\s/.test(this.buffer[newPos])) {
+      newPos--;
+    }
+    while (newPos > 0 && !/\s/.test(this.buffer[newPos - 1])) {
+      newPos--;
+    }
+    const distance = this.cursorPos - newPos;
+    if (distance > 0) {
+      this.terminal.write(TerminalAdapter.cursorBack(distance));
+      this.cursorPos = newPos;
+    }
+  }
+  moveWordRight() {
+    if (this.cursorPos >= this.buffer.length) return;
+    let newPos = this.cursorPos;
+    while (newPos < this.buffer.length && !/\s/.test(this.buffer[newPos])) {
+      newPos++;
+    }
+    while (newPos < this.buffer.length && /\s/.test(this.buffer[newPos])) {
+      newPos++;
+    }
+    const distance = newPos - this.cursorPos;
+    if (distance > 0) {
+      this.terminal.write(TerminalAdapter.cursorForward(distance));
+      this.cursorPos = newPos;
+    }
+  }
+  clearLine() {
+    this.buffer = "";
+    this.cursorPos = 0;
+  }
+  deleteToEnd() {
+    this.buffer = this.buffer.slice(0, this.cursorPos);
+  }
+  deleteToStart() {
+    this.buffer = this.buffer.slice(this.cursorPos);
+    this.cursorPos = 0;
+  }
+  deleteWord() {
+    if (this.cursorPos === 0) return;
+    let newPos = this.cursorPos - 1;
+    while (newPos > 0 && /\s/.test(this.buffer[newPos])) {
+      newPos--;
+    }
+    while (newPos > 0 && !/\s/.test(this.buffer[newPos - 1])) {
+      newPos--;
+    }
+    this.buffer = this.buffer.slice(0, newPos) + this.buffer.slice(this.cursorPos);
+    this.cursorPos = newPos;
+  }
+  // Called by shell to render the line with prompt
+  render(prompt) {
+    this.terminal.write(
+      "\r" + TerminalAdapter.clearToEndOfLine() + prompt + this.buffer
+    );
+    const cursorOffset = this.buffer.length - this.cursorPos;
+    if (cursorOffset > 0) {
+      this.terminal.write(TerminalAdapter.cursorBack(cursorOffset));
+    }
+  }
+};
+
+// src/input/history.ts
+var DEFAULT_STORAGE_KEY = "reifydb-shell-history";
+var MAX_HISTORY = 1e3;
+var LocalStorageHistoryStorage = class {
+  key;
+  constructor(key = DEFAULT_STORAGE_KEY) {
+    this.key = key;
+  }
+  load() {
+    try {
+      const stored = localStorage.getItem(this.key);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        if (Array.isArray(parsed)) {
+          return parsed.filter((e) => typeof e === "string");
+        }
+      }
+    } catch {
+    }
+    return [];
+  }
+  save(entries) {
+    try {
+      localStorage.setItem(this.key, JSON.stringify(entries));
+    } catch {
+    }
+  }
+};
+var MemoryHistoryStorage = class {
+  entries = [];
+  load() {
+    return [...this.entries];
+  }
+  save(entries) {
+    this.entries = [...entries];
+  }
+};
+var CommandHistory = class {
+  entries = [];
+  position = -1;
+  savedInput = "";
+  storage;
+  constructor(storage, historyKey) {
+    this.storage = storage ?? new LocalStorageHistoryStorage(historyKey);
+    this.entries = this.storage.load();
+  }
+  add(command) {
+    const trimmed = command.trim();
+    if (!trimmed) return;
+    if (this.entries.length > 0 && this.entries[this.entries.length - 1] === trimmed) {
+      this.reset();
+      return;
+    }
+    this.entries.push(trimmed);
+    if (this.entries.length > MAX_HISTORY) {
+      this.entries = this.entries.slice(-MAX_HISTORY);
+    }
+    this.storage.save(this.entries);
+    this.reset();
+  }
+  previous(currentInput) {
+    if (this.entries.length === 0) return null;
+    if (this.position === -1) {
+      this.savedInput = currentInput;
+      this.position = this.entries.length;
+    }
+    if (this.position > 0) {
+      this.position--;
+      return this.entries[this.position];
+    }
+    return null;
+  }
+  next() {
+    if (this.position === -1) return null;
+    if (this.position < this.entries.length - 1) {
+      this.position++;
+      return this.entries[this.position];
+    }
+    if (this.position === this.entries.length - 1) {
+      this.position = -1;
+      return this.savedInput;
+    }
+    return null;
+  }
+  reset() {
+    this.position = -1;
+    this.savedInput = "";
+  }
+  getAll() {
+    return [...this.entries];
+  }
+  clear() {
+    this.entries = [];
+    this.position = -1;
+    this.savedInput = "";
+    this.storage.save(this.entries);
+  }
+};
+
+// src/input/multiline.ts
+var MultilineBuffer = class {
+  lines = [];
+  get isEmpty() {
+    return this.lines.length === 0;
+  }
+  get content() {
+    return this.lines.join(" ");
+  }
+  addLine(line) {
+    this.lines.push(line);
+  }
+  clear() {
+    this.lines = [];
+  }
+  isComplete() {
+    const full = this.content.trim();
+    return full.endsWith(";");
+  }
+  static isStatementComplete(input) {
+    const trimmed = input.trim();
+    return trimmed.endsWith(";");
+  }
+};
+
+// src/commands/dot-commands.ts
+var C = TerminalAdapter.COLORS;
+async function handleDotCommand(input, context) {
+  const parts = input.trim().split(/\s+/);
+  const command = parts[0].toLowerCase();
+  const args = parts.slice(1);
+  switch (command) {
+    case ".help":
+      showHelp(context.terminal);
+      return { handled: true };
+    case ".quit":
+    case ".exit":
+      context.terminal.writeln(`${C.yellow}Goodbye!${C.reset}`);
+      context.terminal.writeln("");
+      return { handled: true, exit: true };
+    case ".clear":
+      context.clearScreen();
+      return { handled: true };
+    case ".mode":
+      handleMode(args, context);
+      return { handled: true };
+    case ".history":
+      showHistory(context);
+      return { handled: true };
+    case ".tables":
+      await showTables(context);
+      return { handled: true };
+    case ".schema":
+      await showSchema(args, context);
+      return { handled: true };
+    default:
+      if (command.startsWith(".")) {
+        context.terminal.writeln(
+          `${C.red}Unknown command: ${command}${C.reset}`
+        );
+        context.terminal.writeln(`Type ${C.cyan}.help${C.reset} for available commands.`);
+        return { handled: true };
+      }
+      return { handled: false };
+  }
+}
+function showHelp(terminal) {
+  terminal.writeln("");
+  terminal.writeln(`${C.bold}${C.cyan}Available commands:${C.reset}`);
+  terminal.writeln("");
+  terminal.writeln(`  ${C.green}.help${C.reset}              Show this help message`);
+  terminal.writeln(`  ${C.green}.quit${C.reset}, ${C.green}.exit${C.reset}      Exit message`);
+  terminal.writeln(`  ${C.green}.clear${C.reset}             Clear the screen`);
+  terminal.writeln(`  ${C.green}.mode${C.reset} [mode]       Set display mode (truncate|full)`);
+  terminal.writeln(`  ${C.green}.history${C.reset}           Show command history`);
+  terminal.writeln(`  ${C.green}.tables${C.reset}            List all tables`);
+  terminal.writeln(`  ${C.green}.schema${C.reset} [table]    Show table schema`);
+  terminal.writeln("");
+  terminal.writeln(`${C.bold}${C.cyan}Keyboard shortcuts:${C.reset}`);
+  terminal.writeln("");
+  terminal.writeln(`  ${C.yellow}Left/Right${C.reset}         Move cursor`);
+  terminal.writeln(`  ${C.yellow}Ctrl+Left/Right${C.reset}    Move by word`);
+  terminal.writeln(`  ${C.yellow}Home/End${C.reset}           Start/end of line`);
+  terminal.writeln(`  ${C.yellow}Ctrl+A/E${C.reset}           Start/end of line`);
+  terminal.writeln(`  ${C.yellow}Ctrl+U${C.reset}             Clear line`);
+  terminal.writeln(`  ${C.yellow}Ctrl+W${C.reset}             Delete word`);
+  terminal.writeln(`  ${C.yellow}Up/Down${C.reset}            Navigate history`);
+  terminal.writeln(`  ${C.yellow}Ctrl+C${C.reset}             Cancel input`);
+  terminal.writeln("");
+  terminal.writeln(`${C.dim}Statements must end with a semicolon (;)${C.reset}`);
+  terminal.writeln("");
+}
+function handleMode(args, context) {
+  const terminal = context.terminal;
+  if (args.length === 0) {
+    terminal.writeln(`Current display mode: ${C.cyan}${context.displayMode}${C.reset}`);
+    return;
+  }
+  const mode = args[0].toLowerCase();
+  if (mode === "truncate" || mode === "full") {
+    context.setDisplayMode(mode);
+    terminal.writeln(`Display mode set to: ${C.cyan}${mode}${C.reset}`);
+  } else {
+    terminal.writeln(
+      `${C.red}Unknown mode: ${mode}${C.reset}. Use 'truncate' or 'full'.`
+    );
+  }
+}
+function showHistory(context) {
+  const terminal = context.terminal;
+  const entries = context.history.getAll();
+  if (entries.length === 0) {
+    terminal.writeln(`${C.dim}No command history${C.reset}`);
+    return;
+  }
+  terminal.writeln("");
+  terminal.writeln(`${C.bold}${C.cyan}Command history:${C.reset}`);
+  terminal.writeln("");
+  const toShow = entries.slice(-20);
+  const startIdx = entries.length - toShow.length;
+  toShow.forEach((entry, i) => {
+    const num = String(startIdx + i + 1).padStart(4, " ");
+    terminal.writeln(`${C.dim}${num}${C.reset}  ${entry}`);
+  });
+  if (entries.length > 20) {
+    terminal.writeln("");
+    terminal.writeln(`${C.dim}... and ${entries.length - 20} more entries${C.reset}`);
+  }
+  terminal.writeln("");
+}
+async function showTables(context) {
+  const terminal = context.terminal;
+  if (!context.executor.getTables) {
+    terminal.writeln(`${C.dim}.tables command not supported by this executor${C.reset}`);
+    return;
+  }
+  const tables = await context.executor.getTables();
+  if (tables.length === 0) {
+    terminal.writeln(`${C.dim}No tables found${C.reset}`);
+    return;
+  }
+  terminal.writeln("");
+  terminal.writeln(`${C.bold}${C.cyan}Tables:${C.reset}`);
+  terminal.writeln("");
+  tables.forEach((table) => {
+    terminal.writeln(`  ${C.green}${table}${C.reset}`);
+  });
+  terminal.writeln("");
+}
+async function showSchema(args, context) {
+  const terminal = context.terminal;
+  if (!context.executor.getSchema) {
+    terminal.writeln(`${C.dim}.schema command not supported by this executor${C.reset}`);
+    return;
+  }
+  if (args.length === 0) {
+    terminal.writeln(`${C.red}Usage: .schema <table_name>${C.reset}`);
+    return;
+  }
+  const tableName = args[0];
+  const schema = await context.executor.getSchema(tableName);
+  if (schema) {
+    terminal.writeln("");
+    terminal.writeln(schema);
+    terminal.writeln("");
+  } else {
+    terminal.writeln(`${C.red}Table not found: ${tableName}${C.reset}`);
+  }
+}
+
+// src/output/table.ts
+var TableRenderer = class {
+  data;
+  columns;
+  maxWidth;
+  truncate;
+  constructor(data, options = {}) {
+    this.data = data;
+    this.maxWidth = options.maxWidth ?? 120;
+    this.truncate = options.truncate ?? true;
+    this.columns = this.calculateColumns();
+  }
+  calculateColumns() {
+    if (this.data.length === 0) return [];
+    const columns = /* @__PURE__ */ new Map();
+    for (const row of this.data) {
+      for (const [key, value] of Object.entries(row)) {
+        const valueStr = this.formatValue(value);
+        const currentMax = columns.get(key) ?? key.length;
+        columns.set(key, Math.max(currentMax, valueStr.length));
+      }
+    }
+    return Array.from(columns.entries()).map(([name, width]) => ({
+      name,
+      width: Math.max(width, name.length)
+    }));
+  }
+  formatValue(value) {
+    if (value === null || value === void 0) {
+      return "null";
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+  truncateString(str, maxLen) {
+    if (str.length <= maxLen) return str;
+    if (maxLen <= 3) return str.slice(0, maxLen);
+    return str.slice(0, maxLen - 3) + "...";
+  }
+  render() {
+    if (this.data.length === 0 || this.columns.length === 0) {
+      return ["(no results)"];
+    }
+    const lines = [];
+    let columnsToShow = this.columns;
+    let widths = this.columns.map((c) => c.width);
+    if (this.truncate) {
+      const result = this.fitColumns(this.maxWidth);
+      columnsToShow = result.columns;
+      widths = result.widths;
+    }
+    const separator = "+" + widths.map((w) => "-".repeat(w + 2)).join("+") + "+";
+    lines.push(separator);
+    const headerCells = columnsToShow.map(
+      (col, i) => this.padCenter(col.name, widths[i])
+    );
+    lines.push("| " + headerCells.join(" | ") + " |");
+    lines.push(separator);
+    for (const row of this.data) {
+      const cells = columnsToShow.map((col, i) => {
+        const value = this.formatValue(row[col.name]);
+        const truncated = this.truncate ? this.truncateString(value, widths[i]) : value;
+        return this.padRight(truncated, widths[i]);
+      });
+      lines.push("| " + cells.join(" | ") + " |");
+    }
+    lines.push(separator);
+    return lines;
+  }
+  fitColumns(maxWidth) {
+    const columns = [];
+    const widths = [];
+    let currentWidth = 1;
+    for (const col of this.columns) {
+      const colWidth = Math.min(col.width, 40);
+      const totalColWidth = colWidth + 3;
+      if (currentWidth + totalColWidth <= maxWidth) {
+        columns.push(col);
+        widths.push(colWidth);
+        currentWidth += totalColWidth;
+      } else {
+        break;
+      }
+    }
+    if (columns.length === 0 && this.columns.length > 0) {
+      const firstCol = this.columns[0];
+      const availableWidth = maxWidth - 4;
+      columns.push(firstCol);
+      widths.push(Math.max(availableWidth, 10));
+    }
+    return { columns, widths };
+  }
+  padCenter(str, width) {
+    const padding = width - str.length;
+    if (padding <= 0) return str.slice(0, width);
+    const left = Math.floor(padding / 2);
+    const right = padding - left;
+    return " ".repeat(left) + str + " ".repeat(right);
+  }
+  padRight(str, width) {
+    const padding = width - str.length;
+    if (padding <= 0) return str.slice(0, width);
+    return str + " ".repeat(padding);
+  }
+};
+
+// src/output/formatter.ts
+var C2 = TerminalAdapter.COLORS;
+var OutputFormatter = class {
+  terminal;
+  displayMode;
+  constructor(terminal, displayMode = "truncate") {
+    this.terminal = terminal;
+    this.displayMode = displayMode;
+  }
+  setDisplayMode(mode) {
+    this.displayMode = mode;
+  }
+  formatResult(result) {
+    if (!result.success) {
+      this.formatError(result.error ?? "Unknown error", result.executionTime);
+      return;
+    }
+    if (!result.data || result.data.length === 0) {
+      this.terminal.writeln("");
+      this.terminal.writeln(`${C2.dim}Query executed successfully. No rows returned.${C2.reset}`);
+      this.formatExecutionTime(result.executionTime);
+      return;
+    }
+    this.formatTable(result.data, result.executionTime);
+  }
+  formatTable(data, executionTime) {
+    const renderer = new TableRenderer(data, {
+      maxWidth: this.displayMode === "truncate" ? this.terminal.cols - 2 : void 0,
+      truncate: this.displayMode === "truncate"
+    });
+    const lines = renderer.render();
+    this.terminal.writeln("");
+    for (const line of lines) {
+      this.terminal.writeln(line);
+    }
+    const rowCount = data.length;
+    this.terminal.writeln("");
+    this.terminal.write(
+      `${C2.green}${rowCount} row${rowCount !== 1 ? "s" : ""}${C2.reset}`
+    );
+    this.formatExecutionTime(executionTime);
+  }
+  formatError(error, executionTime) {
+    this.terminal.writeln("");
+    this.terminal.writeln(`${C2.red}Error: ${error}${C2.reset}`);
+    this.formatExecutionTime(executionTime);
+  }
+  formatExecutionTime(ms) {
+    this.terminal.writeln(` ${C2.dim}(${ms}ms)${C2.reset}`);
+  }
+};
+
+// src/shell.ts
+var C3 = COLORS;
+var DEFAULT_PRIMARY_PROMPT = `${C3.cyan}reifydb${C3.reset}${C3.brightBlack}>${C3.reset} `;
+var DEFAULT_CONTINUATION_PROMPT = `${C3.brightBlack}     ...${C3.reset} `;
+var DEFAULT_PRIMARY_PROMPT_LEN = 9;
+var DEFAULT_CONTINUATION_PROMPT_LEN = 8;
+var Shell = class {
+  terminal;
+  lineEditor;
+  history;
+  multiline;
+  executor;
+  formatter;
+  displayMode;
+  isExited = false;
+  // Configurable options
+  primaryPrompt;
+  primaryPromptLen;
+  continuationPrompt;
+  continuationPromptLen;
+  welcomeMessage;
+  onExit;
+  constructor(container, options) {
+    this.executor = options.executor;
+    this.displayMode = options.displayMode ?? "truncate";
+    this.welcomeMessage = options.welcomeMessage;
+    this.onExit = options.onExit;
+    this.primaryPrompt = options.prompt ?? DEFAULT_PRIMARY_PROMPT;
+    this.primaryPromptLen = options.promptLength ?? DEFAULT_PRIMARY_PROMPT_LEN;
+    this.continuationPrompt = options.continuationPrompt ?? DEFAULT_CONTINUATION_PROMPT;
+    this.continuationPromptLen = options.continuationPromptLength ?? DEFAULT_CONTINUATION_PROMPT_LEN;
+    this.terminal = new TerminalAdapter(container, options.theme);
+    this.lineEditor = new LineEditor(this.terminal);
+    this.history = new CommandHistory(options.historyStorage, options.historyKey);
+    this.multiline = new MultilineBuffer();
+    this.formatter = new OutputFormatter(this.terminal, this.displayMode);
+    this.setupKeyHandler();
+  }
+  start() {
+    this.showWelcomeBanner();
+    this.showPrompt();
+    this.terminal.focus();
+  }
+  dispose() {
+    this.isExited = true;
+    this.terminal.dispose();
+  }
+  showWelcomeBanner() {
+    if (this.welcomeMessage === void 0) {
+      this.terminal.writeln("");
+      this.terminal.writeln(`${C3.bold}${C3.cyan}ReifyDB Shell${C3.reset}`);
+      this.terminal.writeln("");
+      this.terminal.writeln(`Type ${C3.green}.help${C3.reset} for available commands`);
+      this.terminal.writeln(`Statements must end with a semicolon ${C3.yellow};${C3.reset}`);
+      this.terminal.writeln("");
+      return;
+    }
+    let lines;
+    if (typeof this.welcomeMessage === "function") {
+      lines = this.welcomeMessage();
+    } else if (Array.isArray(this.welcomeMessage)) {
+      lines = this.welcomeMessage;
+    } else {
+      lines = [this.welcomeMessage];
+    }
+    for (const line of lines) {
+      this.terminal.writeln(line);
+    }
+  }
+  showPrompt() {
+    const prompt = this.multiline.isEmpty ? this.primaryPrompt : this.continuationPrompt;
+    this.terminal.write(prompt);
+  }
+  getCurrentPromptLen() {
+    return this.multiline.isEmpty ? this.primaryPromptLen : this.continuationPromptLen;
+  }
+  setupKeyHandler() {
+    this.terminal.onKey((key, event) => {
+      if (this.isExited) return;
+      this.handleKey(key, event);
+    });
+  }
+  handleKey(key, event) {
+    const code = event.keyCode;
+    if (event.ctrlKey) {
+      switch (event.key.toLowerCase()) {
+        case "a":
+          event.preventDefault();
+          this.lineEditor.moveToStart();
+          return;
+        case "e":
+          event.preventDefault();
+          this.lineEditor.moveToEnd();
+          return;
+        case "u":
+          event.preventDefault();
+          this.lineEditor.clearLine();
+          this.redrawLine();
+          return;
+        case "w":
+          event.preventDefault();
+          this.lineEditor.deleteWord();
+          this.redrawLine();
+          return;
+        case "c":
+          event.preventDefault();
+          this.terminal.writeln("^C");
+          this.lineEditor.clear();
+          this.multiline.clear();
+          this.history.reset();
+          this.showPrompt();
+          return;
+        case "l":
+          event.preventDefault();
+          this.clearScreen();
+          return;
+      }
+      if (code === 37) {
+        event.preventDefault();
+        this.lineEditor.moveWordLeft();
+        return;
+      }
+      if (code === 39) {
+        event.preventDefault();
+        this.lineEditor.moveWordRight();
+        return;
+      }
+      return;
+    }
+    switch (code) {
+      case 13:
+        this.handleEnter();
+        return;
+      case 8:
+        if (this.lineEditor.backspace()) {
+          this.redrawLine();
+        }
+        return;
+      case 46:
+        if (this.lineEditor.delete()) {
+          this.redrawLine();
+        }
+        return;
+      case 37:
+        this.lineEditor.moveLeft();
+        return;
+      case 39:
+        this.lineEditor.moveRight();
+        return;
+      case 38:
+        this.navigateHistory("up");
+        return;
+      case 40:
+        this.navigateHistory("down");
+        return;
+      case 36:
+        this.lineEditor.moveToStart();
+        return;
+      case 35:
+        this.lineEditor.moveToEnd();
+        return;
+      case 9:
+        return;
+      case 27:
+        return;
+    }
+    if (key.length === 1 && !event.ctrlKey && !event.altKey && !event.metaKey) {
+      this.lineEditor.insert(key);
+      this.redrawLine();
+    }
+  }
+  redrawLine() {
+    const prompt = this.multiline.isEmpty ? this.primaryPrompt : this.continuationPrompt;
+    this.lineEditor.render(prompt);
+  }
+  navigateHistory(direction) {
+    let entry;
+    if (direction === "up") {
+      entry = this.history.previous(this.lineEditor.value);
+    } else {
+      entry = this.history.next();
+    }
+    if (entry !== null) {
+      this.lineEditor.setValue(entry);
+      this.redrawLine();
+    }
+  }
+  async handleEnter() {
+    const line = this.lineEditor.value;
+    this.terminal.writeln("");
+    this.lineEditor.clear();
+    if (this.multiline.isEmpty && line.trim().startsWith(".")) {
+      this.history.add(line);
+      const result = await handleDotCommand(line, {
+        terminal: this.terminal,
+        executor: this.executor,
+        history: this.history,
+        displayMode: this.displayMode,
+        setDisplayMode: (mode) => {
+          this.displayMode = mode;
+          this.formatter.setDisplayMode(mode);
+        },
+        clearScreen: () => this.clearScreen()
+      });
+      if (result.exit) {
+        this.isExited = true;
+        if (this.onExit) {
+          this.onExit();
+        }
+        return;
+      }
+      this.showPrompt();
+      return;
+    }
+    this.multiline.addLine(line);
+    if (this.multiline.isComplete()) {
+      const statement = this.multiline.content;
+      this.multiline.clear();
+      this.history.add(statement);
+      this.history.reset();
+      const result = await this.executor.execute(statement);
+      this.formatter.formatResult(result);
+    }
+    this.showPrompt();
+  }
+  clearScreen() {
+    this.terminal.write(TerminalAdapter.clearScreen());
+    this.showPrompt();
+    this.terminal.write(this.lineEditor.value);
+  }
+};
+
+// src/executors/wasm-executor.ts
+var WasmExecutor = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async execute(statement) {
+    const trimmed = statement.trim();
+    const query = trimmed.endsWith(";") ? trimmed.slice(0, -1).trim() : trimmed;
+    if (!query) {
+      return {
+        success: true,
+        data: [],
+        executionTime: 0
+      };
+    }
+    const startTime = performance.now();
+    try {
+      const results = await this.db.admin(query);
+      const endTime = performance.now();
+      return {
+        success: true,
+        data: Array.isArray(results) ? results : [],
+        executionTime: Math.round(endTime - startTime)
+      };
+    } catch (error) {
+      const endTime = performance.now();
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        executionTime: Math.round(endTime - startTime)
+      };
+    }
+  }
+  async getTables() {
+    try {
+      const result = await this.db.admin("FROM system.tables MAP { namespace, name }");
+      if (Array.isArray(result)) {
+        return result.map((row) => {
+          const ns = row.namespace;
+          const name = row.name;
+          return ns ? `${ns}.${name}` : name;
+        });
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  }
+  async getSchema(tableName) {
+    try {
+      const result = await this.db.admin(
+        `FROM system.columns FILTER table = "${tableName}" MAP { name, type }`
+      );
+      if (Array.isArray(result) && result.length > 0) {
+        const columns = result.map(
+          (row) => `  ${row.name}: ${row.type}`
+        ).join(",\n");
+        return `${tableName} {
+${columns}
+}`;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/executors/ws-executor.ts
+var WsExecutor = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async execute(statement) {
+    const trimmed = statement.trim();
+    const query = trimmed.endsWith(";") ? trimmed.slice(0, -1).trim() : trimmed;
+    if (!query) {
+      return {
+        success: true,
+        data: [],
+        executionTime: 0
+      };
+    }
+    const startTime = performance.now();
+    try {
+      const frames = await this.client.admin(query, null, []);
+      const endTime = performance.now();
+      const results = frames[0] ?? [];
+      const data = results.map((row) => {
+        if (row && typeof row === "object") {
+          const plainRow = {};
+          for (const [key, value] of Object.entries(row)) {
+            if (value && typeof value === "object" && typeof value.valueOf === "function") {
+              plainRow[key] = value.valueOf();
+            } else {
+              plainRow[key] = value;
+            }
+          }
+          return plainRow;
+        }
+        return row;
+      });
+      return {
+        success: true,
+        data,
+        executionTime: Math.round(endTime - startTime)
+      };
+    } catch (error) {
+      const endTime = performance.now();
+      let errorMessage;
+      if (error && typeof error === "object" && "diagnostic" in error) {
+        const diagnostic = error.diagnostic;
+        errorMessage = diagnostic.message;
+      } else if (error instanceof Error) {
+        errorMessage = error.message;
+      } else {
+        errorMessage = String(error);
+      }
+      return {
+        success: false,
+        error: errorMessage,
+        executionTime: Math.round(endTime - startTime)
+      };
+    }
+  }
+  async getTables() {
+    try {
+      const frames = await this.client.admin(
+        "FROM system.tables MAP { namespace, name }",
+        null,
+        []
+      );
+      const results = frames[0] ?? [];
+      return results.map((row) => {
+        const r = row;
+        const ns = this.extractValue(r.namespace);
+        const name = this.extractValue(r.name);
+        return ns ? `${ns}.${name}` : name;
+      });
+    } catch {
+      return [];
+    }
+  }
+  async getSchema(tableName) {
+    try {
+      const frames = await this.client.admin(
+        `FROM system.columns FILTER table = "${tableName}" MAP { name, type }`,
+        null,
+        []
+      );
+      const results = frames[0] ?? [];
+      if (results.length > 0) {
+        const columns = results.map((row) => {
+          const r = row;
+          return `  ${this.extractValue(r.name)}: ${this.extractValue(r.type)}`;
+        }).join(",\n");
+        return `${tableName} {
+${columns}
+}`;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  extractValue(value) {
+    if (value && typeof value === "object" && typeof value.valueOf === "function") {
+      return value.valueOf();
+    }
+    return value;
+  }
+};
+export {
+  COLORS,
+  CommandHistory,
+  LineEditor,
+  LocalStorageHistoryStorage,
+  MemoryHistoryStorage,
+  MultilineBuffer,
+  OutputFormatter,
+  Shell,
+  TableRenderer,
+  TerminalAdapter,
+  WasmExecutor,
+  WsExecutor,
+  defaultTheme,
+  handleDotCommand
+};
+//# sourceMappingURL=index.js.map