@dbsp/cli 1.0.0

package/dist/chunk-ZSGVJFWG.js

@@ -0,0 +1,2304 @@
+import {
+  TABLE_OPTIONS,
+  config,
+  isValidTableOption
+} from "./chunk-U5DSGBS2.js";
+
+// src/repl/db-connection.ts
+import pg from "pg";
+var { Pool } = pg;
+var MAX_ROWS = 100;
+async function createDbConnection(connectionString) {
+  if (!connectionString.startsWith("postgres://") && !connectionString.startsWith("postgresql://")) {
+    throw new Error(
+      `Invalid connection URL: must start with postgres:// or postgresql://`
+    );
+  }
+  const pool = new Pool({
+    connectionString,
+    max: 1,
+    // Single connection for REPL
+    connectionTimeoutMillis: 1e4,
+    idleTimeoutMillis: 3e4
+  });
+  try {
+    await pool.query("SELECT 1");
+  } catch (error) {
+    await pool.end();
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to connect to database: ${message}`);
+  }
+  let txClient = null;
+  async function runTransactionControl(sql) {
+    if (!txClient) {
+      throw new Error("No active transaction. Use .begin first.");
+    }
+    try {
+      await txClient.query(sql);
+    } finally {
+      txClient.release();
+      txClient = null;
+    }
+  }
+  async function executeRaw(query, params = []) {
+    const startTime = performance.now();
+    const target = txClient ?? pool;
+    try {
+      const poolResult = await target.query(query, [...params]);
+      const endTime = performance.now();
+      const executionTimeMs = Math.round(endTime - startTime);
+      const rows = poolResult.rows ?? [];
+      const columns = poolResult.fields?.map((f) => f.name) ?? [];
+      const rowCount = poolResult.rowCount ?? rows?.length ?? 0;
+      const truncated = rows.length > MAX_ROWS;
+      const limitedRows = truncated ? rows.slice(0, MAX_ROWS) : rows;
+      return {
+        rows: limitedRows,
+        columns,
+        rowCount,
+        executionTimeMs,
+        truncated
+      };
+    } catch (error) {
+      const endTime = performance.now();
+      const executionTimeMs = Math.round(endTime - startTime);
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        rows: [],
+        columns: [],
+        rowCount: 0,
+        executionTimeMs,
+        error: message
+      };
+    }
+  }
+  return {
+    executeRaw,
+    async ping() {
+      try {
+        await pool.query("SELECT 1");
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async close() {
+      if (txClient) {
+        try {
+          await txClient.query("ROLLBACK");
+        } catch {
+        }
+        txClient.release();
+        txClient = null;
+      }
+      await pool.end();
+    },
+    getPool() {
+      return pool;
+    },
+    async beginTransaction() {
+      if (txClient) {
+        throw new Error(
+          "Transaction already active. Use .commit or .rollback first."
+        );
+      }
+      txClient = await pool.connect();
+      try {
+        await txClient.query("BEGIN");
+      } catch (err) {
+        txClient.release();
+        txClient = null;
+        throw err;
+      }
+    },
+    async commitTransaction() {
+      return runTransactionControl("COMMIT");
+    },
+    async rollbackTransaction() {
+      return runTransactionControl("ROLLBACK");
+    },
+    get inTransaction() {
+      return txClient !== null;
+    }
+  };
+}
+function getDatabaseName(connectionString) {
+  try {
+    const url = new URL(connectionString);
+    return url.pathname.slice(1) || url.hostname;
+  } catch {
+    return "database";
+  }
+}
+
+// src/repl/dot-commands.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+// src/utils/identifier-validation.ts
+var InvalidIdentifierError = class extends Error {
+  constructor(value, identifierType, reason) {
+    super(
+      `Invalid ${identifierType} identifier ${JSON.stringify(value)}: ${reason}`
+    );
+    this.value = value;
+    this.identifierType = identifierType;
+    this.name = "InvalidIdentifierError";
+  }
+  value;
+  identifierType;
+};
+var VALID_IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_$]*$/;
+function validateIdentifier(value, identifierType) {
+  if (!value || value.length === 0) {
+    throw new InvalidIdentifierError(value, identifierType, "cannot be empty");
+  }
+  if (/[\u0000-\u001f\u007f]/u.test(value)) {
+    throw new InvalidIdentifierError(
+      value,
+      identifierType,
+      "contains control characters or NUL byte"
+    );
+  }
+  const byteLen = Buffer.byteLength(value, "utf8");
+  if (byteLen > 63) {
+    throw new InvalidIdentifierError(
+      value,
+      identifierType,
+      `exceeds maximum length of 63 bytes (got ${byteLen})`
+    );
+  }
+  if (!VALID_IDENTIFIER_RE.test(value)) {
+    if (/^[0-9]/.test(value)) {
+      throw new InvalidIdentifierError(
+        value,
+        identifierType,
+        "cannot start with a digit"
+      );
+    }
+    throw new InvalidIdentifierError(
+      value,
+      identifierType,
+      "contains invalid characters (only letters, digits, underscore, and $ allowed)"
+    );
+  }
+}
+
+// src/utils/path-containment.ts
+import { isAbsolute, relative, resolve, sep } from "path";
+var PathEscapeError = class extends Error {
+  constructor(originalArg, resolvedPath, baseDir) {
+    super(
+      `Path escapes working directory: "${originalArg}" resolves to "${resolvedPath}" which is outside "${baseDir}"`
+    );
+    this.originalArg = originalArg;
+    this.resolvedPath = resolvedPath;
+    this.baseDir = baseDir;
+    this.name = "PathEscapeError";
+  }
+  originalArg;
+  resolvedPath;
+  baseDir;
+};
+function validatePathInCwd(arg, cwd = process.cwd()) {
+  const sanitised = arg.replace(/\0/g, "");
+  const resolved = resolve(cwd, sanitised);
+  const base = resolve(cwd);
+  const isRelative = !isAbsolute(sanitised);
+  if (isRelative) {
+    const rel = relative(base, resolved);
+    if (rel === ".." || rel.startsWith("../") || rel.startsWith(`..${sep}`)) {
+      throw new PathEscapeError(arg, resolved, base);
+    }
+  }
+  return resolved;
+}
+
+// src/repl/csv.ts
+import { readFile } from "fs/promises";
+var CsvParseError = class _CsvParseError extends Error {
+  /** 1-based physical line number where the error was detected. */
+  line;
+  constructor(line, message) {
+    super(`CSV parse error at line ${line}: ${message}`);
+    this.name = "CsvParseError";
+    this.line = line;
+    Object.setPrototypeOf(this, _CsvParseError.prototype);
+  }
+};
+var CANDIDATE_SEPARATORS = [",", ";", "	", "|"];
+var CANDIDATE_QUOTES = ['"', "'"];
+function sniffCsvFormat(lines, schemaColumns) {
+  if (lines.length === 0) {
+    return { separator: ",", quote: '"', hasHeader: false, columns: [] };
+  }
+  const quote = detectQuoteChar(lines);
+  const separator = detectSeparator(lines, quote);
+  const firstRowFields = parseCsvLine(lines[0], separator, quote);
+  const hasHeader = detectHeader(firstRowFields, schemaColumns);
+  const columns = hasHeader ? firstRowFields.map((f) => f.trim()) : firstRowFields.map((_, i) => `col_${i}`);
+  return { separator, quote, hasHeader, columns };
+}
+function detectQuoteChar(lines) {
+  const joined = lines.join("");
+  let bestQuote = '"';
+  let bestCount = 0;
+  for (const q of CANDIDATE_QUOTES) {
+    const count = joined.split(q).length - 1;
+    if (count > bestCount) {
+      bestCount = count;
+      bestQuote = q;
+    }
+  }
+  return bestQuote;
+}
+function detectSeparator(lines, quote) {
+  let bestSep = ",";
+  let bestScore = -1;
+  for (const sep2 of CANDIDATE_SEPARATORS) {
+    const counts = lines.map((line) => parseCsvLine(line, sep2, quote).length);
+    const firstCount = counts[0];
+    if (firstCount <= 1) continue;
+    const consistent = counts.every((c) => c === firstCount);
+    const score = consistent ? firstCount * 10 : firstCount;
+    if (score > bestScore) {
+      bestScore = score;
+      bestSep = sep2;
+    }
+  }
+  return bestSep;
+}
+function detectHeader(firstRowFields, schemaColumns) {
+  if (firstRowFields.length === 0) return false;
+  if (schemaColumns && schemaColumns.length > 0) {
+    const schemaSet = new Set(schemaColumns.map((c) => c.toLowerCase().trim()));
+    const matchCount = firstRowFields.filter(
+      (f) => schemaSet.has(f.toLowerCase().trim())
+    ).length;
+    if (matchCount > firstRowFields.length / 2) return true;
+  }
+  return firstRowFields.every((field) => {
+    const trimmed = field.trim();
+    if (trimmed === "") return false;
+    return /^[a-z][a-z0-9_]*$/.test(trimmed);
+  });
+}
+function parseCsvLine(line, separator, quote, physicalLine) {
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  let i = 0;
+  while (i < line.length) {
+    const char = line[i];
+    if (inQuotes) {
+      if (char === quote) {
+        if (i + 1 < line.length && line[i + 1] === quote) {
+          current += quote;
+          i += 2;
+          continue;
+        }
+        if (physicalLine !== void 0 && i + 1 < line.length && line[i + 1] !== separator) {
+          throw new CsvParseError(
+            physicalLine,
+            `unexpected character '${line[i + 1]}' after closing quote`
+          );
+        }
+        inQuotes = false;
+        i++;
+        continue;
+      }
+      current += char;
+      i++;
+    } else {
+      if (char === quote && current === "") {
+        inQuotes = true;
+        i++;
+        continue;
+      }
+      if (char === separator) {
+        fields.push(current);
+        current = "";
+        i++;
+        continue;
+      }
+      current += char;
+      i++;
+    }
+  }
+  if (inQuotes && physicalLine !== void 0) {
+    throw new CsvParseError(
+      physicalLine,
+      "unterminated quoted field (EOF in quote)"
+    );
+  }
+  fields.push(current);
+  return fields;
+}
+function tokeniseCsvContent(content, quoteChar) {
+  const rows = [];
+  const q = quoteChar;
+  let inQuote = false;
+  let rowStart = 0;
+  let physicalLine = 1;
+  let rowStartPhysicalLine = 1;
+  let firstLineOfRowEnd = -1;
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    if (ch === q) {
+      if (!inQuote) {
+        inQuote = true;
+      } else {
+        if (i + 1 < content.length && content[i + 1] === q) {
+          i++;
+        } else {
+          inQuote = false;
+        }
+      }
+    } else if (ch === "\n") {
+      if (firstLineOfRowEnd === -1) {
+        firstLineOfRowEnd = i > 0 && content[i - 1] === "\r" ? i - 1 : i;
+      }
+      physicalLine++;
+      if (!inQuote) {
+        const rawEnd = i > 0 && content[i - 1] === "\r" ? i - 1 : i;
+        const rawText = content.slice(rowStart, rawEnd);
+        const rawFirstLine = firstLineOfRowEnd === rawEnd ? rawText : content.slice(rowStart, firstLineOfRowEnd);
+        rows.push({
+          rawText,
+          rawFirstLine,
+          startPhysicalLine: rowStartPhysicalLine
+        });
+        rowStart = i + 1;
+        rowStartPhysicalLine = physicalLine;
+        firstLineOfRowEnd = -1;
+      }
+    } else if (ch === "\r") {
+      if (i + 1 >= content.length || content[i + 1] !== "\n") {
+        if (firstLineOfRowEnd === -1) {
+          firstLineOfRowEnd = i;
+        }
+        physicalLine++;
+        if (!inQuote) {
+          const rawText = content.slice(rowStart, i);
+          const rawFirstLine = firstLineOfRowEnd === i ? rawText : content.slice(rowStart, firstLineOfRowEnd);
+          rows.push({
+            rawText,
+            rawFirstLine,
+            startPhysicalLine: rowStartPhysicalLine
+          });
+          rowStart = i + 1;
+          rowStartPhysicalLine = physicalLine;
+          firstLineOfRowEnd = -1;
+        }
+      }
+    }
+  }
+  if (rowStart < content.length) {
+    if (inQuote) {
+      throw new CsvParseError(
+        rowStartPhysicalLine,
+        "unterminated quoted field at end of file"
+      );
+    }
+    const rawText = content.slice(rowStart).replace(/\r$/, "");
+    if (rawText.length > 0) {
+      const rawFirstLine = firstLineOfRowEnd === -1 ? rawText : content.slice(rowStart, firstLineOfRowEnd);
+      rows.push({
+        rawText,
+        rawFirstLine,
+        startPhysicalLine: rowStartPhysicalLine
+      });
+    }
+  } else if (inQuote) {
+    throw new CsvParseError(
+      rowStartPhysicalLine,
+      "unterminated quoted field at end of file"
+    );
+  }
+  return rows;
+}
+function parseLogicalRow(row, separator, quote) {
+  const text = row.rawText;
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (inQuotes) {
+      if (ch === quote) {
+        if (i + 1 < text.length && text[i + 1] === quote) {
+          current += quote;
+          i += 2;
+          continue;
+        }
+        const next = text[i + 1];
+        if (next !== void 0 && next !== separator && next !== "\r" && next !== "\n") {
+          throw new CsvParseError(
+            row.startPhysicalLine,
+            `unexpected character '${next}' after closing quote`
+          );
+        }
+        inQuotes = false;
+        i++;
+        continue;
+      }
+      current += ch;
+      i++;
+    } else {
+      if (ch === quote && current === "") {
+        inQuotes = true;
+        i++;
+        continue;
+      }
+      if (ch === separator) {
+        fields.push(current);
+        current = "";
+        i++;
+        continue;
+      }
+      current += ch;
+      i++;
+    }
+  }
+  fields.push(current);
+  return fields;
+}
+async function parseCsvFile(filePath, schemaColumns) {
+  const raw = await readFile(filePath, "utf-8");
+  if (raw.length === 0) {
+    return {
+      format: { separator: ",", quote: '"', hasHeader: false, columns: [] },
+      rows: []
+    };
+  }
+  const SNIFF_LINE_COUNT = 10;
+  const physicalLines = raw.split("\n");
+  const sampleLines = physicalLines.slice(0, SNIFF_LINE_COUNT * 3).map((l) => l.replace(/\r$/, "")).filter((l) => l.trim() !== "").slice(0, SNIFF_LINE_COUNT);
+  if (sampleLines.length === 0) {
+    return {
+      format: { separator: ",", quote: '"', hasHeader: false, columns: [] },
+      rows: []
+    };
+  }
+  const format = sniffCsvFormat(sampleLines, schemaColumns);
+  const logicalRows = tokeniseCsvContent(raw, format.quote);
+  if (logicalRows.length === 0) {
+    return { format, rows: [] };
+  }
+  const rows = [];
+  let rowIndex = 0;
+  for (const logicalRow of logicalRows) {
+    if (logicalRow.rawText.trim() === "") {
+      continue;
+    }
+    if (rowIndex === 0 && format.hasHeader) {
+      rowIndex++;
+      continue;
+    }
+    const fields = parseLogicalRow(logicalRow, format.separator, format.quote);
+    if (fields.length !== format.columns.length) {
+      throw new CsvParseError(
+        logicalRow.startPhysicalLine,
+        `expected ${format.columns.length} fields, got ${fields.length}`
+      );
+    }
+    const row = {};
+    for (let i = 0; i < format.columns.length; i++) {
+      row[format.columns[i]] = fields[i] ?? "";
+    }
+    rows.push(row);
+    rowIndex++;
+  }
+  return { format, rows };
+}
+function formatCsv(rows, columns) {
+  if (columns.length === 0) return "";
+  const header = columns.map((c) => escapeCsvField(c)).join(",");
+  const dataLines = rows.map(
+    (row) => columns.map((col) => escapeCsvField(formatFieldValue(row[col]))).join(",")
+  );
+  return [header, ...dataLines].join("\n");
+}
+function escapeCsvField(value) {
+  if (value.includes(",") || value.includes("\n") || value.includes("\r") || value.includes('"')) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function formatFieldValue(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+
+// src/repl/dot-commands.ts
+function formatTables(schema) {
+  const tables = schema.tableNames;
+  return `Tables (${tables.length}):
+${tables.map((t) => `  - ${t}`).join("\n")}`;
+}
+function formatTableSchema(schema, tableName) {
+  const table = schema.model.tables.get(tableName);
+  if (!table) {
+    return `\u274C Table not found: ${tableName}`;
+  }
+  const lines = [`Table: ${tableName}`, "Columns:"];
+  for (const col of table.columns) {
+    const nullable = col.nullable ? "" : " (NOT NULL)";
+    lines.push(`  - ${col.name}: ${col.type}${nullable}`);
+  }
+  return lines.join("\n");
+}
+function getRelationDescription(rel) {
+  return `${rel.type} \u2192 ${rel.target}`;
+}
+function formatRelations(schema, tableName) {
+  const relations = Array.from(schema.model.relations.entries());
+  if (tableName) {
+    const tableRelations = relations.filter(
+      ([, rel]) => rel.target === tableName || rel.source === tableName
+    );
+    if (tableRelations.length === 0) {
+      return `No relations found for table: ${tableName}`;
+    }
+    const lines2 = [`Relations for ${tableName}:`];
+    for (const [name, rel] of tableRelations) {
+      lines2.push(`  - ${name}: ${getRelationDescription(rel)}`);
+    }
+    return lines2.join("\n");
+  }
+  const lines = [`Relations (${relations.length}):`];
+  for (const [name, rel] of relations) {
+    lines.push(`  - ${name}: ${getRelationDescription(rel)}`);
+  }
+  return lines.join("\n");
+}
+function handleBooleanToggle(arg, key, label, state) {
+  const requiresDb = key === "execEnabled";
+  if (arg === "on") {
+    if (requiresDb && !state.dbConnection) {
+      return { output: "\u274C No database connection. Use --db option." };
+    }
+    return {
+      output: `\u2713 ${label}: ON`,
+      stateChange: { [key]: true }
+    };
+  }
+  if (arg === "off") {
+    return {
+      output: `\u2713 ${label}: OFF`,
+      stateChange: { [key]: false }
+    };
+  }
+  if (requiresDb && !state.dbConnection) {
+    return { output: "\u274C No database connection. Use --db option." };
+  }
+  const newValue = !state[key];
+  return {
+    output: `\u2713 ${label}: ${newValue ? "ON" : "OFF"}`,
+    stateChange: { [key]: newValue }
+  };
+}
+async function runTransactionAction(state, action) {
+  if (!state.dbConnection) {
+    return { output: "\u274C No database connection. Use --db option." };
+  }
+  const methodMap = {
+    begin: {
+      method: "beginTransaction",
+      expectInTx: false,
+      errorMsg: "Transaction already active. Use .commit or .rollback first.",
+      okOutput: "\u2713 Transaction started (BEGIN)",
+      failPrefix: "Failed to begin transaction",
+      stateChange: { inTransaction: true }
+    },
+    commit: {
+      method: "commitTransaction",
+      expectInTx: true,
+      errorMsg: "No active transaction. Use .begin first.",
+      okOutput: "\u2713 Transaction committed (COMMIT)",
+      failPrefix: "Commit failed",
+      stateChange: { inTransaction: false }
+    },
+    rollback: {
+      method: "rollbackTransaction",
+      expectInTx: true,
+      errorMsg: "No active transaction. Use .begin first.",
+      okOutput: "\u2713 Transaction rolled back (ROLLBACK)",
+      failPrefix: "Rollback failed",
+      stateChange: { inTransaction: false }
+    }
+  };
+  const cfg = methodMap[action];
+  if (state.dbConnection.inTransaction !== cfg.expectInTx) {
+    return { output: `\u274C ${cfg.errorMsg}` };
+  }
+  try {
+    await state.dbConnection[cfg.method]();
+    return { output: cfg.okOutput, stateChange: cfg.stateChange };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { output: `\u274C ${cfg.failPrefix}: ${message}` };
+  }
+}
+function handleHelp() {
+  return {
+    output: `Available commands:
+  .tables           - List all tables
+  .schema <table>   - Show table schema
+  .relations [table]- Show relations (optionally for a specific table)
+  .use [schema]     - Set/clear PostgreSQL schema for multi-tenant
+  .exec [on|off]    - Toggle or set execution mode (requires --db)
+  .explain [on|off] - Toggle EXPLAIN output for queries
+  .parse [on|off]   - Toggle parse tree (AST) output for queries
+  .natural          - Switch to natural query mode
+  .sql              - Switch to SQL mode
+  .output [mode]    - Set output format (json|table|csv)
+  .import <file>    - Execute SQL file (DDL, seed data)
+  .load <table> <f> - Import CSV file into table
+  .dump <table> <f> - Export table to CSV file
+  .begin            - Start a transaction
+  .commit           - Commit the active transaction
+  .rollback         - Rollback the active transaction
+  .help             - Show this help`
+  };
+}
+function handleTables(_arg, schema) {
+  return { output: formatTables(schema) };
+}
+function handleSchema(arg, schema) {
+  if (!arg) {
+    const tableCount = schema.tableNames.length;
+    const relationCount = schema.model.relations.size;
+    return {
+      output: `Schema Summary:
+  - Tables: ${tableCount}
+  - Relations: ${relationCount}
+  Use .schema <table> for details`
+    };
+  }
+  return { output: formatTableSchema(schema, arg) };
+}
+function handleRelations(arg, schema) {
+  return { output: formatRelations(schema, arg || void 0) };
+}
+function handleUse(arg) {
+  if (!arg) {
+    return {
+      output: "Cleared schema scope. Queries now use default schema.",
+      stateChange: { schemaName: void 0 }
+    };
+  }
+  try {
+    validateIdentifier(arg, "schema");
+  } catch (err) {
+    const reason = err instanceof InvalidIdentifierError ? err.message : String(err);
+    return { output: `\u274C ${reason}` };
+  }
+  return {
+    output: `Using schema: ${arg}`,
+    stateChange: { schemaName: arg }
+  };
+}
+function handleExec(arg, _schema, state) {
+  return handleBooleanToggle(arg, "execEnabled", "Execution mode", state);
+}
+function handleNatural() {
+  return {
+    output: "Switched to natural query mode",
+    stateChange: { mode: "natural" }
+  };
+}
+function handleSql() {
+  return {
+    output: "Switched to SQL mode",
+    stateChange: { mode: "sql" }
+  };
+}
+function handleExplain(arg, _schema, state) {
+  return handleBooleanToggle(arg, "explainMode", "EXPLAIN mode", state);
+}
+function handleParse(arg, _schema, state) {
+  return handleBooleanToggle(arg, "parseMode", "Parse mode", state);
+}
+function handleOutput(arg, _schema, state) {
+  const validModes = ["json", "table", "csv"];
+  if (!arg) {
+    return {
+      output: `Current output mode: ${state.outputMode}`
+    };
+  }
+  const requestedMode = arg.toLowerCase();
+  if (!validModes.includes(requestedMode)) {
+    return {
+      output: `\u274C Invalid output mode: ${arg}. Use: json, table, csv`
+    };
+  }
+  return {
+    output: `\u2713 Output mode: ${requestedMode}`,
+    stateChange: { outputMode: requestedMode }
+  };
+}
+var handleBegin = (_arg, _schema, state) => runTransactionAction(state, "begin");
+var handleCommit = (_arg, _schema, state) => runTransactionAction(state, "commit");
+var handleRollback = (_arg, _schema, state) => runTransactionAction(state, "rollback");
+async function handleImport(arg, _schema, state) {
+  if (!arg) {
+    return { output: "\u274C Usage: .import <file.sql>" };
+  }
+  if (!state.dbConnection) {
+    return { output: "\u274C .import requires database connection (--db)" };
+  }
+  let resolvedPath;
+  try {
+    resolvedPath = validatePathInCwd(arg);
+  } catch (err) {
+    const reason = err instanceof PathEscapeError ? err.message : String(err);
+    return { output: `\u274C ${reason}` };
+  }
+  if (!existsSync(resolvedPath)) {
+    return { output: `\u274C File not found: ${arg}` };
+  }
+  try {
+    let sqlContent = readFileSync(resolvedPath, "utf-8");
+    if (state.schemaName) {
+      sqlContent = `SET search_path TO "${state.schemaName}", public;
+${sqlContent}`;
+    }
+    const result = await state.dbConnection.executeRaw(sqlContent, []);
+    if (result.error) {
+      return {
+        output: `\u274C Import failed: ${result.error}`,
+        success: false,
+        error: result.error
+      };
+    }
+    const rowInfo = result.rowCount !== void 0 ? ` (${result.rowCount} rows affected)` : "";
+    const schemaInfo = state.schemaName ? ` (schema: ${state.schemaName})` : "";
+    return {
+      output: `\u2705 Imported: ${arg}${rowInfo}${schemaInfo}`,
+      success: true
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      output: `\u274C Import failed: ${message}`,
+      success: false,
+      error: message
+    };
+  }
+}
+async function handleLoad(arg, schema, state) {
+  const loadParts = arg.split(/\s+/);
+  const tableName = loadParts[0];
+  const filePath = loadParts.slice(1).join(" ");
+  if (!tableName || !filePath) {
+    return { output: "\u274C Usage: .load <table> <file.csv>" };
+  }
+  if (!state.dbConnection) {
+    return { output: "\u274C .load requires database connection (--db)" };
+  }
+  try {
+    validateIdentifier(tableName, "table");
+  } catch (err) {
+    const reason = err instanceof InvalidIdentifierError ? err.message : String(err);
+    return { output: `\u274C ${reason}` };
+  }
+  const loadTable = schema.model.tables.get(tableName);
+  const schemaColumns = loadTable ? loadTable.columns.map((c) => c.name) : void 0;
+  let loadFilePath;
+  try {
+    loadFilePath = validatePathInCwd(filePath);
+  } catch (err) {
+    const reason = err instanceof PathEscapeError ? err.message : String(err);
+    return { output: `\u274C ${reason}` };
+  }
+  if (!existsSync(loadFilePath)) {
+    return { output: `\u274C File not found: ${filePath}` };
+  }
+  try {
+    const csvData = await parseCsvFile(loadFilePath, schemaColumns);
+    if (csvData.rows.length === 0) {
+      return { output: "\u26A0\uFE0F CSV file is empty \u2014 no rows to import" };
+    }
+    const csvColumns = [...csvData.format.columns];
+    for (const col of csvColumns) {
+      try {
+        validateIdentifier(col, "column");
+      } catch (err) {
+        const reason = err instanceof InvalidIdentifierError ? err.message : String(err);
+        return {
+          output: `\u274C CSV header contains invalid column: ${reason}`
+        };
+      }
+    }
+    const validColumns = schemaColumns ? csvColumns.filter((c) => schemaColumns.includes(c)) : csvColumns;
+    if (validColumns.length === 0) {
+      return {
+        output: `\u274C No matching columns found in CSV: ${csvColumns.join(", ")}`
+      };
+    }
+    const BATCH_SIZE = 100;
+    let totalInserted = 0;
+    for (let i = 0; i < csvData.rows.length; i += BATCH_SIZE) {
+      const batch = csvData.rows.slice(i, i + BATCH_SIZE);
+      const params = [];
+      const valueRows = [];
+      for (const row of batch) {
+        const placeholders = [];
+        for (const col of validColumns) {
+          params.push(row[col] ?? null);
+          placeholders.push(`$${params.length}`);
+        }
+        valueRows.push(`(${placeholders.join(", ")})`);
+      }
+      const quotedCols = validColumns.map((c) => `"${c}"`).join(", ");
+      const schemaPrefix = state.schemaName ? `"${state.schemaName}".` : "";
+      const sql = `INSERT INTO ${schemaPrefix}"${tableName}" (${quotedCols}) VALUES ${valueRows.join(", ")}`;
+      const result = await state.dbConnection.executeRaw(sql, params);
+      if (result.error) {
+        return {
+          output: `\u274C Insert failed at row ${totalInserted + 1}: ${result.error}`,
+          success: false,
+          error: result.error
+        };
+      }
+      totalInserted += batch.length;
+    }
+    const formatInfo = `separator: '${csvData.format.separator === "	" ? "\\t" : csvData.format.separator}', header: ${csvData.format.hasHeader ? "yes" : "no"}`;
+    return {
+      output: `\u2705 Loaded ${totalInserted} rows into ${tableName} (${formatInfo})`,
+      success: true
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      output: `\u274C Load failed: ${message}`,
+      success: false,
+      error: message
+    };
+  }
+}
+async function handleDump(arg, schema, state) {
+  const dumpParts = arg.split(/\s+/);
+  const dumpTableName = dumpParts[0];
+  const dumpFilePath = dumpParts.slice(1).join(" ");
+  if (!dumpTableName || !dumpFilePath) {
+    return { output: "\u274C Usage: .dump <table> <file.csv>" };
+  }
+  if (!state.dbConnection) {
+    return { output: "\u274C .dump requires database connection (--db)" };
+  }
+  try {
+    validateIdentifier(dumpTableName, "table");
+  } catch (err) {
+    const reason = err instanceof InvalidIdentifierError ? err.message : String(err);
+    return { output: `\u274C ${reason}` };
+  }
+  const dumpTable = schema.model.tables.get(dumpTableName);
+  if (!dumpTable) {
+    return { output: `\u274C Table not found: ${dumpTableName}` };
+  }
+  let resolvedDumpPath;
+  try {
+    resolvedDumpPath = validatePathInCwd(dumpFilePath);
+  } catch (err) {
+    const reason = err instanceof PathEscapeError ? err.message : String(err);
+    return { output: `\u274C ${reason}` };
+  }
+  try {
+    const schemaPrefix = state.schemaName ? `"${state.schemaName}".` : "";
+    const result = await state.dbConnection.executeRaw(
+      `SELECT * FROM ${schemaPrefix}"${dumpTableName}"`
+    );
+    if (result.error) {
+      return {
+        output: `\u274C Query failed: ${result.error}`,
+        success: false,
+        error: result.error
+      };
+    }
+    const columns = result.columns.length > 0 ? result.columns : dumpTable.columns.map((c) => c.name);
+    const csv = formatCsv(result.rows, columns);
+    writeFileSync(resolvedDumpPath, `${csv}
+`, "utf-8");
+    return {
+      output: `\u2705 Dumped ${result.rows.length} rows from ${dumpTableName} to ${dumpFilePath}`,
+      success: true
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      output: `\u274C Dump failed: ${message}`,
+      success: false,
+      error: message
+    };
+  }
+}
+function handleExit() {
+  return { output: "Exiting..." };
+}
+var DOT_COMMAND_HANDLERS = /* @__PURE__ */ new Map([
+  [".help", handleHelp],
+  [".tables", handleTables],
+  [".schema", handleSchema],
+  [".relations", handleRelations],
+  [".use", handleUse],
+  [".exec", handleExec],
+  [".natural", handleNatural],
+  [".sql", handleSql],
+  [".explain", handleExplain],
+  [".parse", handleParse],
+  [".output", handleOutput],
+  [".begin", handleBegin],
+  [".commit", handleCommit],
+  [".rollback", handleRollback],
+  [".import", handleImport],
+  [".load", handleLoad],
+  [".dump", handleDump],
+  [".exit", handleExit],
+  [".quit", handleExit]
+  // alias — same handler instance
+]);
+async function processDotCommand(input, schema, state) {
+  const parts = input.split(/\s+/);
+  const command = (parts[0] ?? "").toLowerCase();
+  const arg = parts.slice(1).join(" ").trim().replace(/\0/g, "");
+  const handler = DOT_COMMAND_HANDLERS.get(command);
+  if (!handler) {
+    return { output: `\u274C Unknown command: ${command}` };
+  }
+  return handler(arg, schema, state);
+}
+
+// src/repl/completion.ts
+function levenshtein(a, b) {
+  const aLower = a.toLowerCase();
+  const bLower = b.toLowerCase();
+  if (aLower === bLower) return 0;
+  if (aLower.length === 0) return bLower.length;
+  if (bLower.length === 0) return aLower.length;
+  const matrix = Array.from(
+    { length: aLower.length + 1 },
+    (_, i) => Array.from(
+      { length: bLower.length + 1 },
+      (_2, j) => i === 0 ? j : j === 0 ? i : 0
+    )
+  );
+  for (let i = 1; i <= aLower.length; i++) {
+    for (let j = 1; j <= bLower.length; j++) {
+      const cost = aLower[i - 1] === bLower[j - 1] ? 0 : 1;
+      const deletion = matrix[i - 1]?.[j] ?? 0;
+      const insertion = matrix[i]?.[j - 1] ?? 0;
+      const substitution = matrix[i - 1]?.[j - 1] ?? 0;
+      matrix[i][j] = Math.min(
+        deletion + 1,
+        insertion + 1,
+        substitution + cost
+      );
+    }
+  }
+  return matrix[aLower.length]?.[bLower.length] ?? 0;
+}
+function suggestClosestMatch(input, candidates, maxDistance = 3) {
+  if (!input || candidates.length === 0) return null;
+  const matches = candidates.map((c) => ({ name: c, distance: levenshtein(input, c) })).filter((m) => m.distance <= maxDistance && m.distance > 0).sort((a, b) => a.distance - b.distance);
+  return matches[0]?.name ?? null;
+}
+function enhanceErrorWithSuggestion(error, tableNames, columnNames = []) {
+  const tableMatch = error.match(/Unknown table:\s*(\w+)/i);
+  if (tableMatch?.[1]) {
+    const unknownTable = tableMatch[1];
+    const suggestion = suggestClosestMatch(unknownTable, tableNames);
+    if (suggestion) {
+      return `${error}
+
+Did you mean '${suggestion}'?`;
+    }
+  }
+  if (columnNames.length > 0) {
+    const columnMatch = error.match(/Unknown column:\s*(\w+)/i);
+    if (columnMatch?.[1]) {
+      const unknownColumn = columnMatch[1];
+      const suggestion = suggestClosestMatch(unknownColumn, columnNames);
+      if (suggestion) {
+        return `${error}
+
+Did you mean '${suggestion}'?`;
+      }
+    }
+  }
+  return error;
+}
+var DOT_COMMANDS = [
+  { text: ".help", label: ".help", type: "command", description: "Show help" },
+  {
+    text: ".tables",
+    label: ".tables",
+    type: "command",
+    description: "List tables"
+  },
+  {
+    text: ".schema",
+    label: ".schema",
+    type: "command",
+    description: "Show schema"
+  },
+  {
+    text: ".relations",
+    label: ".relations",
+    type: "command",
+    description: "List relations"
+  },
+  {
+    text: ".history",
+    label: ".history",
+    type: "command",
+    description: "Show history"
+  },
+  {
+    text: ".sql",
+    label: ".sql",
+    type: "command",
+    description: "Switch to SQL mode"
+  },
+  {
+    text: ".natural",
+    label: ".natural",
+    type: "command",
+    description: "Switch to natural mode"
+  },
+  {
+    text: ".split",
+    label: ".split",
+    type: "command",
+    description: "Toggle split view"
+  },
+  {
+    text: ".clear",
+    label: ".clear",
+    type: "command",
+    description: "Clear screen"
+  },
+  {
+    text: ".exit",
+    label: ".exit",
+    type: "command",
+    description: "Exit REPL"
+  },
+  {
+    text: ".quit",
+    label: ".quit",
+    type: "command",
+    description: "Exit REPL (alias)"
+  },
+  {
+    text: ".aliasing",
+    label: ".aliasing",
+    type: "command",
+    description: "Toggle column aliasing mode"
+  },
+  {
+    text: ".strategy",
+    label: ".strategy",
+    type: "command",
+    description: "Show/set include strategy"
+  },
+  {
+    text: ".dialect",
+    label: ".dialect",
+    type: "command",
+    description: "Show/set SQL dialect"
+  },
+  {
+    text: ".use",
+    label: ".use",
+    type: "command",
+    description: "Set schema for queries"
+  },
+  {
+    text: ".exec",
+    label: ".exec",
+    type: "command",
+    description: "Toggle execution mode"
+  },
+  {
+    text: ".import",
+    label: ".import",
+    type: "command",
+    description: "Execute SQL file"
+  },
+  {
+    text: ".parse",
+    label: ".parse",
+    type: "command",
+    description: "Toggle parse tree (AST) output"
+  },
+  {
+    text: ".explain",
+    label: ".explain",
+    type: "command",
+    description: "Toggle EXPLAIN prefix for queries"
+  },
+  {
+    text: ".table",
+    label: ".table",
+    type: "command",
+    description: "Configure table display options"
+  }
+];
+var KEYWORDS = [
+  // Pipe operator (NQL syntax)
+  {
+    text: "|",
+    label: "|",
+    type: "keyword",
+    description: "Pipe to next clause"
+  },
+  {
+    text: "where",
+    label: "where",
+    type: "keyword",
+    description: "Filter results"
+  },
+  {
+    text: "with",
+    label: "with",
+    type: "keyword",
+    description: "Include related data"
+  },
+  {
+    text: "select",
+    label: "select",
+    type: "keyword",
+    description: "Select columns"
+  },
+  {
+    text: "group",
+    label: "group",
+    type: "keyword",
+    description: "Group by columns"
+  },
+  { text: "limit", label: "limit", type: "keyword", description: "Limit rows" },
+  {
+    text: "offset",
+    label: "offset",
+    type: "keyword",
+    description: "Skip rows"
+  },
+  {
+    text: "order",
+    label: "order",
+    type: "keyword",
+    description: "Sort results"
+  },
+  {
+    text: "asc",
+    label: "asc",
+    type: "keyword",
+    description: "Ascending order"
+  },
+  {
+    text: "desc",
+    label: "desc",
+    type: "keyword",
+    description: "Descending order"
+  },
+  { text: "and", label: "and", type: "keyword", description: "Logical AND" },
+  { text: "or", label: "or", type: "keyword", description: "Logical OR" },
+  {
+    text: "true",
+    label: "true",
+    type: "keyword",
+    description: "Boolean true"
+  },
+  {
+    text: "false",
+    label: "false",
+    type: "keyword",
+    description: "Boolean false"
+  },
+  { text: "null", label: "null", type: "keyword", description: "Null value" },
+  // Range operators (PostgreSQL)
+  {
+    text: "overlaps",
+    label: "overlaps",
+    type: "keyword",
+    description: "Range overlap operator (&&)"
+  },
+  {
+    text: "contains",
+    label: "contains",
+    type: "keyword",
+    description: "Range contains element (@>)"
+  },
+  {
+    text: "containedBy",
+    label: "containedBy",
+    type: "keyword",
+    description: "Range within another (<@)"
+  },
+  // String operators
+  {
+    text: "like",
+    label: "like",
+    type: "keyword",
+    description: "Pattern matching (LIKE)"
+  },
+  // Set operators
+  {
+    text: "in",
+    label: "in",
+    type: "keyword",
+    description: "Value in set (IN)"
+  }
+];
+var CompletionProvider = class {
+  tables = [];
+  columns = /* @__PURE__ */ new Map();
+  relations = [];
+  // Relations per table - key is table name, value is relations for that table
+  tableRelations = /* @__PURE__ */ new Map();
+  constructor(schema) {
+    this.initializeFromSchema(schema);
+  }
+  /**
+   * Initialize completions from schema
+   * ARCH-005: Uses schema.model (ModelIR) directly
+   */
+  initializeFromSchema(schema) {
+    for (const [tableName, table] of schema.model.tables) {
+      this.tables.push({
+        text: tableName,
+        label: tableName,
+        type: "table",
+        description: "Table"
+      });
+      const tableColumns = [];
+      for (const col of table.columns) {
+        tableColumns.push({
+          text: col.name,
+          label: col.name,
+          type: "column",
+          description: col.type
+        });
+      }
+      this.columns.set(tableName, tableColumns);
+    }
+    for (const [relName] of schema.model.relations) {
+      this.relations.push({
+        text: relName,
+        label: relName,
+        type: "relation",
+        description: "Relation"
+      });
+      if (relName.includes(".")) {
+        const [tableName, ...relParts] = relName.split(".");
+        if (!tableName) continue;
+        const simpleRelName = relParts.join(".");
+        if (!this.tableRelations.has(tableName)) {
+          this.tableRelations.set(tableName, []);
+        }
+        this.tableRelations.get(tableName)?.push({
+          text: simpleRelName,
+          label: simpleRelName,
+          type: "relation",
+          description: `Relation from ${tableName}`
+        });
+      }
+    }
+  }
+  /**
+   * Get completions for the given input
+   */
+  complete(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      return [...this.tables, ...DOT_COMMANDS.slice(0, 5)];
+    }
+    if (trimmed.startsWith(".")) {
+      return this.filterSuggestions(DOT_COMMANDS, trimmed);
+    }
+    const context = this.parseContext(input);
+    switch (context.expecting) {
+      case "table":
+        return this.filterSuggestions(this.tables, context.partial);
+      case "keyword":
+        return this.filterSuggestions(KEYWORDS, context.partial);
+      case "column": {
+        const tableCols = this.columns.get(context.table ?? "") ?? [];
+        return this.filterSuggestions(
+          [...tableCols, ...KEYWORDS],
+          context.partial
+        );
+      }
+      case "relation": {
+        const tableRels = context.table ? this.tableRelations.get(context.table) ?? [] : [];
+        const relSuggestions = tableRels.length > 0 ? tableRels : this.relations;
+        return this.filterSuggestions(relSuggestions, context.partial);
+      }
+      case "value":
+        return this.filterSuggestions(
+          KEYWORDS.filter((k) => ["true", "false", "null"].includes(k.text)),
+          context.partial
+        );
+      default:
+        return this.filterSuggestions(
+          [...this.tables, ...KEYWORDS],
+          context.partial
+        );
+    }
+  }
+  /**
+   * Parse input to determine completion context
+   */
+  parseContext(input) {
+    const endsWithSpace = input.endsWith(" ");
+    const words = input.toLowerCase().split(/\s+/).filter((w) => w.length > 0);
+    if (words.length === 0) {
+      return { expecting: "table", partial: "" };
+    }
+    const partial = endsWithSpace ? "" : words[words.length - 1] ?? "";
+    const contextWords = endsWithSpace ? words : words.slice(0, -1);
+    const lastContextWord = contextWords[contextWords.length - 1];
+    if (lastContextWord === "with") {
+      const table = this.findTableInInput(words);
+      return { expecting: "relation", partial, table };
+    }
+    if (lastContextWord === "where") {
+      const table = this.findTableInInput(words);
+      return { expecting: "column", partial, table };
+    }
+    if (lastContextWord === "and" || lastContextWord === "or") {
+      const table = this.findTableInInput(words);
+      return { expecting: "column", partial, table };
+    }
+    if (lastContextWord && /^[=!<>]+$/.test(lastContextWord)) {
+      return { expecting: "value", partial };
+    }
+    if (contextWords.length === 0) {
+      return { expecting: "table", partial };
+    }
+    const firstWordIsTable = this.tables.some(
+      (t) => t.text.toLowerCase() === contextWords[0]
+    );
+    if (firstWordIsTable) {
+      return {
+        expecting: "keyword",
+        partial,
+        table: contextWords[0]
+      };
+    }
+    return { expecting: "any", partial };
+  }
+  /**
+   * Find table name in the input words
+   */
+  findTableInInput(words) {
+    for (const word of words) {
+      if (this.tables.some((t) => t.text.toLowerCase() === word)) {
+        return word;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Filter suggestions by prefix
+   */
+  filterSuggestions(suggestions, prefix) {
+    if (!prefix) return suggestions;
+    const lower = prefix.toLowerCase();
+    return suggestions.filter(
+      (s) => s.text.toLowerCase().startsWith(lower) || s.label.toLowerCase().includes(lower)
+    );
+  }
+  /**
+   * Get table names for direct access
+   */
+  getTableNames() {
+    return this.tables.map((t) => t.text);
+  }
+  /**
+   * Get column names for a table
+   */
+  getColumnNames(tableName) {
+    return (this.columns.get(tableName) ?? []).map((c) => c.text);
+  }
+  /**
+   * Get relation names
+   */
+  getRelationNames() {
+    return this.relations.map((r) => r.text);
+  }
+  /**
+   * Apply a completion to the current input.
+   * Returns the new input text with the partial word replaced by the completion.
+   *
+   * @param input - Current input text
+   * @param completionText - The completion text to insert
+   * @returns New input text with completion applied
+   */
+  applyCompletion(input, completionText) {
+    const endsWithSpace = input.endsWith(" ");
+    if (endsWithSpace) {
+      return input + completionText;
+    }
+    const words = input.split(/\s+/);
+    if (words.length === 0) {
+      return completionText;
+    }
+    words[words.length - 1] = completionText;
+    return words.join(" ");
+  }
+};
+
+// src/repl/mode-escape.ts
+function parseInputMode(input, mode) {
+  const trimmed = input.trim();
+  const escaped = trimmed.startsWith("!");
+  const content = escaped ? trimmed.slice(1).trim() : trimmed;
+  const isRawSql = mode === "natural" && escaped || mode === "sql" && !escaped;
+  return { content, isRawSql, escaped };
+}
+function getModeWarning(mode, escaped) {
+  if (mode === "sql" && !escaped) {
+    return "SQL mode: direct SQL";
+  }
+  if (mode === "natural" && escaped) {
+    return "Escaped to raw SQL with !";
+  }
+  if (mode === "sql" && escaped) {
+    return "Escaped to natural query with !";
+  }
+  return "Natural query mode";
+}
+
+// src/repl/nql-executor.ts
+import {
+  extractPseudoColumnKeywords,
+  plan
+} from "@dbsp/core";
+import { compile as compileNql } from "@dbsp/nql";
+function extractIntentSummary(compiled, intentType) {
+  if (compiled.query) {
+    const q = compiled.query;
+    return {
+      type: "query",
+      table: q.from,
+      with: (q.include ?? []).map((i) => i.relation),
+      hasWhere: !!q.where,
+      hasGroupBy: !!(q.groupBy && q.groupBy.length > 0),
+      hasOrderBy: !!(q.orderBy && q.orderBy.length > 0),
+      ctes: []
+      // CTEs are at program level, not in CompileResult
+    };
+  }
+  if (compiled.mutation) {
+    const m = compiled.mutation;
+    return {
+      type: intentType,
+      table: m.table,
+      with: [],
+      hasWhere: "where" in m && !!m.where,
+      hasGroupBy: false,
+      hasOrderBy: false,
+      ctes: []
+    };
+  }
+  if (compiled.setOperation) {
+    const setOp = compiled.setOperation;
+    const leftLeaf = "from" in setOp.left ? setOp.left : null;
+    return {
+      type: "setOperation",
+      table: leftLeaf?.from ?? "",
+      with: [],
+      hasWhere: leftLeaf != null ? !!leftLeaf.where : false,
+      hasGroupBy: false,
+      hasOrderBy: false,
+      ctes: []
+    };
+  }
+  return {
+    type: intentType,
+    table: "",
+    with: [],
+    hasWhere: false,
+    hasGroupBy: false,
+    hasOrderBy: false,
+    ctes: []
+  };
+}
+var NqlParseError = class extends Error {
+  constructor(errors) {
+    const messages = errors.map((e) => e.message).join("\n");
+    super(`NQL parse error:
+${messages}`);
+    this.errors = errors;
+    this.name = "NqlParseError";
+  }
+  errors;
+};
+var NqlCompileError = class extends Error {
+  constructor(message) {
+    super(`NQL compile error: ${message}`);
+    this.name = "NqlCompileError";
+  }
+};
+async function compileNqlToSql(nql, model, options) {
+  const {
+    createPgsqlCompileOnlyAdapter,
+    compileSetOperation,
+    createLeafCompileFn
+  } = await import("@dbsp/adapter-pgsql");
+  const adapter = createPgsqlCompileOnlyAdapter({
+    ...options?.schemaName !== void 0 && {
+      schemaName: options.schemaName
+    },
+    ...options?.dbCasing !== void 0 && {
+      dbCasing: options.dbCasing
+    }
+  });
+  const compiled = compileNqlToIntent(nql, model);
+  if (compiled.query) {
+    const queryIntent = compiled.query;
+    const planReport = plan(queryIntent, model, {
+      dialectCapabilities: adapter.dialectCapabilities
+    });
+    const compiledQuery = adapter.compile(planReport, { model });
+    return {
+      sql: compiledQuery.sql,
+      params: compiledQuery.parameters,
+      intentType: "query",
+      intent: extractIntentSummary(compiled, "query"),
+      planReport
+    };
+  }
+  if (compiled.setOperation) {
+    const compileFn = createLeafCompileFn(adapter, model, plan);
+    const result = compileSetOperation(compiled.setOperation, compileFn);
+    return {
+      sql: result.sql,
+      params: result.parameters,
+      intentType: "setOperation",
+      intent: extractIntentSummary(compiled, "setOperation")
+    };
+  }
+  if (compiled.mutation) {
+    const mutation = compiled.mutation;
+    switch (mutation.type) {
+      case "insert": {
+        const compiledQuery = adapter.compileInsert(mutation);
+        return {
+          sql: compiledQuery.sql,
+          params: compiledQuery.parameters,
+          intentType: "insert",
+          intent: extractIntentSummary(compiled, "insert")
+        };
+      }
+      case "update": {
+        const compiledQuery = adapter.compileUpdate(mutation);
+        return {
+          sql: compiledQuery.sql,
+          params: compiledQuery.parameters,
+          intentType: "update",
+          intent: extractIntentSummary(compiled, "update")
+        };
+      }
+      case "delete": {
+        const compiledQuery = adapter.compileDelete(mutation);
+        return {
+          sql: compiledQuery.sql,
+          params: compiledQuery.parameters,
+          intentType: "delete",
+          intent: extractIntentSummary(compiled, "delete")
+        };
+      }
+      case "upsert": {
+        const compiledQuery = adapter.compileUpsert(mutation);
+        return {
+          sql: compiledQuery.sql,
+          params: compiledQuery.parameters,
+          intentType: "upsert",
+          intent: extractIntentSummary(compiled, "upsert")
+        };
+      }
+      default:
+        throw new NqlCompileError(
+          `Unknown mutation type: ${JSON.stringify(mutation)}`
+        );
+    }
+  }
+  throw new NqlCompileError(
+    "NQL compiled to neither query, mutation, nor set operation"
+  );
+}
+function compileNqlToIntent(nql, _model) {
+  const compilerOptions = extractPseudoColumnKeywords(_model);
+  const result = compileNql(nql, _model, void 0, compilerOptions);
+  if (!result.success) {
+    throw new NqlParseError(result.errors);
+  }
+  if (!result.ast) {
+    throw new NqlCompileError("Compilation succeeded but no AST produced");
+  }
+  return result.ast;
+}
+
+// src/repl/engine/repl-engine.ts
+var DIALECT_STRATEGIES = {
+  postgresql: ["auto", "join", "subquery", "cte", "lateral", "json_agg"],
+  mysql: ["auto", "join", "subquery", "cte", "json_agg"],
+  sqlite: ["auto", "join", "subquery", "cte"],
+  mssql: ["auto", "join", "subquery", "cte"],
+  duckdb: ["auto", "join", "subquery", "cte", "json_agg"]
+};
+function isInsideStringLiteral(input) {
+  let inString = false;
+  for (let i = 0; i < input.length - 1; i++) {
+    if (input[i] === "'") {
+      if (inString && i + 1 < input.length - 1 && input[i + 1] === "'") {
+        i++;
+      } else {
+        inString = !inString;
+      }
+    }
+  }
+  return inString;
+}
+var borderHandler = {
+  field: "borderStyle",
+  label: "borders",
+  // Border style values (none / outline / rounded / etc.) are all-lowercase —
+  // normalize input so e.g. `.table borders NONE` matches.
+  parse: (s) => s.toLowerCase()
+};
+var headerHandler = {
+  field: "headerFormatter",
+  label: "headers",
+  // Header-formatter values include camelCase (capitalCase / snakeCase / camelCase) —
+  // preserve original case so the user-typed value matches TABLE_OPTIONS exactly.
+  parse: (s) => s
+};
+var TABLE_OPTION_HANDLERS = {
+  borders: borderHandler,
+  border: borderHandler,
+  overflow: {
+    field: "overflow",
+    label: "overflow",
+    // Overflow values (truncate / wrap) are all-lowercase — normalize input.
+    parse: (s) => s.toLowerCase()
+  },
+  headers: headerHandler,
+  header: headerHandler,
+  padding: {
+    field: "padding",
+    label: "padding",
+    parse: (s) => Number.parseInt(s, 10)
+  }
+};
+var ReplEngine = class {
+  state;
+  listeners = [];
+  schema;
+  schemaPath;
+  model;
+  dbConnection = null;
+  completionProvider;
+  databaseUrl;
+  continuationBuffer = "";
+  engineDotHandlers;
+  constructor(config2) {
+    this.schema = config2.schema;
+    this.schemaPath = config2.schemaPath;
+    this.model = config2.schema.model;
+    this.databaseUrl = config2.databaseUrl;
+    this.completionProvider = new CompletionProvider(config2.schema);
+    this.state = {
+      mode: "natural",
+      execMode: config2.initialExecMode ?? false,
+      connected: false,
+      explainMode: false,
+      parseMode: config2.initialParseMode ?? false,
+      aliasingMode: "always",
+      includeStrategy: "auto",
+      dialect: "postgresql",
+      ...config2.initialSchemaName !== void 0 && {
+        schemaName: config2.initialSchemaName
+      },
+      ...config2.dbCasing !== void 0 && { dbCasing: config2.dbCasing },
+      outputMode: "json",
+      outputLayout: "full",
+      planVerbosity: "normal",
+      inTransaction: false
+    };
+    const exitHandler = this.handleExitCommand.bind(this);
+    this.engineDotHandlers = /* @__PURE__ */ new Map([
+      [".exit", exitHandler],
+      [".quit", exitHandler],
+      [".clear", this.handleClearCommand.bind(this)],
+      [".help", this.handleHelpCommand.bind(this)],
+      [".history", this.handleHistoryCommand.bind(this)],
+      [".aliasing", this.handleAliasingCommand.bind(this)],
+      [".strategy", this.handleStrategyCommand.bind(this)],
+      [".dialect", this.handleDialectCommand.bind(this)],
+      [".table", this.handleTableCommand.bind(this)],
+      [".show", this.handleShowCommand.bind(this)],
+      [".close", this.handleCloseCommand.bind(this)],
+      [".layout", this.handleLayoutCommand.bind(this)],
+      [".plan", this.handlePlanCommand.bind(this)]
+    ]);
+  }
+  /**
+   * Initialize database connection if configured.
+   * Must be called after construction for async init.
+   */
+  async init() {
+    if (!this.databaseUrl) return;
+    try {
+      this.dbConnection = await createDbConnection(this.databaseUrl);
+      this.state.connected = true;
+      const dbName = getDatabaseName(this.databaseUrl);
+      this.emit({
+        type: "info",
+        message: `\u2713 Connected to database: ${dbName}`
+      });
+      this.emitStateChange();
+    } catch (error) {
+      this.state.connected = false;
+      const message = error instanceof Error ? error.message : String(error);
+      this.emit({
+        type: "init-error",
+        message: `Connection failed: ${message}`
+      });
+      this.emitStateChange();
+    }
+  }
+  /** Subscribe to engine events. Returns unsubscribe function. */
+  on(handler) {
+    this.listeners.push(handler);
+    return () => {
+      const idx = this.listeners.indexOf(handler);
+      if (idx >= 0) this.listeners.splice(idx, 1);
+    };
+  }
+  /** Get current state (readonly snapshot). */
+  getState() {
+    return { ...this.state };
+  }
+  /** Get the completion provider for the UI. */
+  getCompletionProvider() {
+    return this.completionProvider;
+  }
+  /** Get schema for UI display. */
+  getSchema() {
+    return this.schema;
+  }
+  /** Get schema path for header display. */
+  getSchemaPath() {
+    return this.schemaPath;
+  }
+  /** Get database name for header display. */
+  getDatabaseName() {
+    return this.databaseUrl ? getDatabaseName(this.databaseUrl) : void 0;
+  }
+  /**
+   * Main entry point: process user input.
+   * Handles dot commands, raw SQL, and NQL queries.
+   */
+  async submit(input) {
+    const trimmed = input.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      this.continuationBuffer = "";
+      return;
+    }
+    if (trimmed.endsWith("\\")) {
+      this.continuationBuffer += (this.continuationBuffer ? "\n" : "") + trimmed.slice(0, -1);
+      return;
+    }
+    const merged = this.continuationBuffer ? `${this.continuationBuffer}
+${trimmed}` : trimmed;
+    this.continuationBuffer = "";
+    if (merged.startsWith(".")) {
+      await this.processDotCommand(merged);
+      return;
+    }
+    const { content, isRawSql, escaped } = parseInputMode(
+      merged,
+      this.state.mode
+    );
+    if (!content) {
+      this.emit({
+        type: "error",
+        message: this.state.mode === "sql" ? "Empty query. Enter SQL or use ! for natural query" : "Empty query. Enter query or use ! for raw SQL"
+      });
+      return;
+    }
+    if (isRawSql) {
+      await this.handleRawSql(content, escaped);
+    } else {
+      await this.handleNql(content);
+    }
+  }
+  /** Cleanup resources. */
+  async destroy() {
+    if (this.dbConnection) {
+      await this.dbConnection.close();
+      this.dbConnection = null;
+      this.state.connected = false;
+    }
+  }
+  // ========================================================================
+  // Private: event emission
+  // ========================================================================
+  emit(event) {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  emitStateChange() {
+    this.emit({ type: "state-change", state: { ...this.state } });
+  }
+  // ========================================================================
+  // Private: dot command processing
+  // ========================================================================
+  async processDotCommand(input) {
+    const [rawCmd = "", ...args] = input.trim().split(/\s+/);
+    const cmd = rawCmd.toLowerCase();
+    const arg = args.join(" ").trim();
+    const engineHandler = this.engineDotHandlers.get(cmd);
+    if (engineHandler) {
+      engineHandler(arg);
+      return;
+    }
+    const batchState = {
+      mode: this.state.mode,
+      execEnabled: this.state.execMode,
+      schemaName: this.state.schemaName,
+      dbConnection: this.dbConnection ?? void 0,
+      explainMode: this.state.explainMode,
+      parseMode: this.state.parseMode,
+      model: this.model,
+      outputMode: this.state.outputMode,
+      inTransaction: this.state.inTransaction,
+      ...this.state.dbCasing !== void 0 && {
+        dbCasing: this.state.dbCasing
+      }
+    };
+    const result = await processDotCommand(input, this.schema, batchState);
+    this.applyDotCommandStateChange(result.stateChange);
+    if (result.error) {
+      this.emit({ type: "error", message: result.output });
+    } else {
+      this.emit({ type: "info", message: result.output });
+    }
+  }
+  // ========================================================================
+  // Private: engine-level dot-command handlers
+  // ========================================================================
+  handleExitCommand(_arg) {
+    this.emit({ type: "exit" });
+  }
+  handleClearCommand(_arg) {
+    this.emit({ type: "clear" });
+  }
+  handleHelpCommand(_arg) {
+    this.emit({ type: "info", message: "SHOW_HELP" });
+  }
+  handleHistoryCommand(_arg) {
+    this.emit({ type: "show-history" });
+  }
+  handleAliasingCommand(_arg) {
+    const newMode = this.state.aliasingMode === "always" ? "onCollision" : "always";
+    this.state.aliasingMode = newMode;
+    this.emitStateChange();
+    this.emit({
+      type: "info",
+      message: `\u{1F3F7}\uFE0F Column aliasing mode: ${newMode}${newMode === "always" ? " (all included columns prefixed)" : " (only colliding columns prefixed)"}`
+    });
+  }
+  handleStrategyCommand(arg) {
+    const strategyArg = arg?.toLowerCase();
+    const validStrategies = DIALECT_STRATEGIES[this.state.dialect] ?? [];
+    if (!strategyArg) {
+      const lines = [
+        `\u{1F517} Include Strategy: ${this.state.includeStrategy.toUpperCase()}`,
+        `Dialect: ${this.state.dialect}`,
+        `Available: ${validStrategies.join(", ")}`,
+        `Usage: .strategy ${validStrategies.join(" | ")}`
+      ];
+      this.emit({ type: "info", message: lines.join("\n") });
+    } else if (validStrategies.includes(strategyArg)) {
+      this.state.includeStrategy = strategyArg;
+      this.emitStateChange();
+      this.emit({
+        type: "info",
+        message: `\u2713 Include strategy: ${strategyArg.toUpperCase()}`
+      });
+    } else {
+      this.emit({
+        type: "error",
+        message: `\u274C Unknown or unavailable strategy: ${strategyArg}. Available: ${validStrategies.join(", ")}`
+      });
+    }
+  }
+  handleDialectCommand(arg) {
+    const dialectArg = arg?.toLowerCase();
+    const validDialects = Object.keys(DIALECT_STRATEGIES);
+    if (!dialectArg) {
+      const lines = [
+        `\u{1F5C4}\uFE0F SQL Dialect: ${this.state.dialect}`,
+        `Available: ${validDialects.join(", ")}`,
+        `Usage: .dialect ${validDialects.join(" | ")}`
+      ];
+      this.emit({ type: "info", message: lines.join("\n") });
+    } else if (validDialects.includes(dialectArg)) {
+      const strategies = DIALECT_STRATEGIES[dialectArg];
+      this.state.dialect = dialectArg;
+      if (strategies && !strategies.includes(this.state.includeStrategy)) {
+        this.state.includeStrategy = "join";
+        this.emitStateChange();
+        this.emit({
+          type: "info",
+          message: `\u2713 Dialect: ${dialectArg}
+\u26A0 Strategy reset to 'join' (previous not available for ${dialectArg})`
+        });
+      } else {
+        this.emitStateChange();
+        this.emit({ type: "info", message: `\u2713 Dialect: ${dialectArg}` });
+      }
+    } else {
+      this.emit({
+        type: "error",
+        message: `\u274C Unknown dialect: ${dialectArg}. Available: ${validDialects.join(", ")}`
+      });
+    }
+  }
+  handleTableCommand(arg) {
+    this.handleTableConfig(arg);
+  }
+  handleShowCommand(arg) {
+    const validViews = [
+      "sql",
+      "plan",
+      "results",
+      "params",
+      "dump"
+    ];
+    const viewArg = arg?.toLowerCase();
+    if (!viewArg) {
+      this.emit({
+        type: "info",
+        message: `\u{1F4CB} Inspection panel views: ${validViews.join(", ")}
+Usage: .show ${validViews.join(" | ")}`
+      });
+    } else if (validViews.includes(viewArg)) {
+      this.emit({ type: "show-panel", view: viewArg });
+    } else {
+      this.emit({
+        type: "error",
+        message: `\u274C Unknown panel view: ${viewArg}. Available: ${validViews.join(", ")}`
+      });
+    }
+  }
+  handleCloseCommand(_arg) {
+    this.emit({ type: "close-panel" });
+  }
+  handleLayoutCommand(arg) {
+    const validLayouts = ["compact", "results", "sql", "full"];
+    const layoutArg = arg?.toLowerCase();
+    if (!layoutArg) {
+      this.emit({
+        type: "info",
+        message: `\u{1F4D0} Output layout: ${this.state.outputLayout}
+Available: ${validLayouts.join(", ")}
+Usage: .layout ${validLayouts.join(" | ")}`
+      });
+    } else if (validLayouts.includes(layoutArg)) {
+      this.state.outputLayout = layoutArg;
+      this.emitStateChange();
+      this.emit({ type: "layout-change", layout: this.state.outputLayout });
+      this.emit({ type: "info", message: `\u2713 Output layout: ${layoutArg}` });
+    } else {
+      this.emit({
+        type: "error",
+        message: `\u274C Unknown layout: ${layoutArg}. Available: ${validLayouts.join(", ")}`
+      });
+    }
+  }
+  handlePlanCommand(arg) {
+    const validLevels = ["compact", "normal", "verbose"];
+    const level = arg?.toLowerCase();
+    if (!level) {
+      this.emit({
+        type: "info",
+        message: `\u{1F4CB} Plan verbosity: ${this.state.planVerbosity}
+Available: ${validLevels.join(", ")}
+Usage: .plan ${validLevels.join(" | ")}`
+      });
+    } else if (validLevels.includes(level)) {
+      this.state.planVerbosity = level;
+      this.emitStateChange();
+      this.emit({ type: "info", message: `\u2713 Plan verbosity: ${level}` });
+    } else {
+      this.emit({
+        type: "error",
+        message: `\u274C Invalid plan verbosity: ${level}. Use: ${validLevels.join(", ")}`
+      });
+    }
+  }
+  applyDotCommandStateChange(stateChange) {
+    if (!stateChange) return;
+    if (stateChange.mode !== void 0) this.state.mode = stateChange.mode;
+    if (stateChange.execEnabled !== void 0) {
+      this.state.execMode = stateChange.execEnabled;
+    }
+    if ("schemaName" in stateChange) {
+      if (stateChange.schemaName !== void 0) {
+        this.state.schemaName = stateChange.schemaName;
+      } else {
+        delete this.state.schemaName;
+      }
+    }
+    if (stateChange.explainMode !== void 0) {
+      this.state.explainMode = stateChange.explainMode;
+    }
+    if (stateChange.parseMode !== void 0) {
+      this.state.parseMode = stateChange.parseMode;
+    }
+    if (stateChange.outputMode !== void 0) {
+      this.state.outputMode = stateChange.outputMode;
+    }
+    if (stateChange.inTransaction !== void 0) {
+      this.state.inTransaction = stateChange.inTransaction;
+    }
+    this.emitStateChange();
+  }
+  // ========================================================================
+  // Private: .table config
+  // ========================================================================
+  handleTableConfig(arg) {
+    const tableConfig = config.getTable();
+    const parts = arg.split(/\s+/);
+    const option = parts[0]?.toLowerCase() ?? "";
+    const value = parts[1] ?? "";
+    if (!option) {
+      this.emit({
+        type: "info",
+        message: `Table Configuration:
+  borders: ${tableConfig.borderStyle}
+  overflow: ${tableConfig.overflow}
+  headers: ${tableConfig.headerFormatter}
+  padding: ${tableConfig.padding}`
+      });
+      return;
+    }
+    if (option === "reset") {
+      config.resetTable();
+      this.emit({
+        type: "info",
+        message: "\u2713 Table configuration reset to defaults"
+      });
+      return;
+    }
+    const handler = TABLE_OPTION_HANDLERS[option];
+    if (!handler) {
+      this.emit({
+        type: "error",
+        message: `Unknown option: ${option}. Options: borders, overflow, headers, padding, reset`
+      });
+      return;
+    }
+    if (!value) {
+      this.emit({
+        type: "info",
+        message: `Current: ${tableConfig[handler.field]}
+Options: ${TABLE_OPTIONS[handler.field].join(", ")}`
+      });
+      return;
+    }
+    const parsed = handler.parse(value);
+    if (isValidTableOption(handler.field, parsed)) {
+      config.updateTable({ [handler.field]: parsed });
+      this.emit({ type: "info", message: `\u2713 ${handler.label} = ${parsed}` });
+    } else {
+      this.emit({
+        type: "error",
+        message: `Invalid value. Options: ${TABLE_OPTIONS[handler.field].join(", ")}`
+      });
+    }
+  }
+  // ========================================================================
+  // Private: raw SQL handling
+  // ========================================================================
+  async handleRawSql(content, escaped) {
+    const queryResult = {
+      sql: content,
+      params: [],
+      plan: {
+        strategy: "RAW_SQL",
+        rootTable: "",
+        tables: [],
+        decisions: [],
+        warnings: [
+          { message: getModeWarning(this.state.mode, escaped) },
+          ...!this.state.execMode || !this.state.connected ? [{ message: "(compile-only, use .exec on to execute)" }] : []
+        ].filter((w) => w.message),
+        cteCount: 0,
+        planningTimeMs: 0
+      }
+    };
+    this.emit({ type: "query-result", result: queryResult });
+    if (this.state.execMode && this.state.connected && this.dbConnection) {
+      try {
+        const execResult = await this.dbConnection.executeRaw(content, []);
+        this.emit({
+          type: "execution-result",
+          result: execResult,
+          query: queryResult
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.emit({
+          type: "query-result",
+          result: { sql: content, params: [], error: message }
+        });
+      }
+    }
+  }
+  // ========================================================================
+  // Private: NQL handling
+  // ========================================================================
+  async handleNql(content) {
+    if (!this.model) {
+      this.emit({
+        type: "error",
+        message: "No schema model available for NQL compilation"
+      });
+      return;
+    }
+    try {
+      const trimmed = content.trim();
+      const hasBangSuffix = trimmed.endsWith("!") && !isInsideStringLiteral(trimmed);
+      const nqlContent = hasBangSuffix ? trimmed.slice(0, -1).trim() : content;
+      const result = await compileNqlToSql(nqlContent, this.model, {
+        ...this.state.schemaName ? { schemaName: this.state.schemaName } : {},
+        ...this.state.dbCasing ? { dbCasing: this.state.dbCasing } : {}
+      });
+      const isMutation = result.intentType !== "query" && result.intentType !== "setOperation";
+      const isDryRun = isMutation && !hasBangSuffix;
+      const finalSql = !isMutation && this.state.explainMode ? `EXPLAIN ${result.sql}` : result.sql;
+      const planInfo = isMutation ? isDryRun ? "DRY-RUN (add ! to execute)" : "EXECUTED" : "";
+      const queryResult = this.buildQueryResult(
+        result,
+        finalSql,
+        isMutation,
+        isDryRun,
+        planInfo
+      );
+      this.emit({ type: "query-result", result: queryResult });
+      if (this.shouldExecuteQuery(isMutation, isDryRun) && this.dbConnection) {
+        const execResult = await this.dbConnection.executeRaw(
+          finalSql,
+          result.params
+        );
+        this.emit({
+          type: "execution-result",
+          result: execResult,
+          query: queryResult
+        });
+      }
+    } catch (err) {
+      const tableNames = this.schema.tableNames;
+      const rawError = err instanceof Error ? err.message : String(err);
+      const enhancedError = enhanceErrorWithSuggestion(rawError, tableNames);
+      this.emit({
+        type: "query-result",
+        result: { sql: "", params: [], error: enhancedError }
+      });
+    }
+  }
+  // ========================================================================
+  // Private: NQL helpers
+  // ========================================================================
+  buildQueryResult(nqlResult, finalSql, isMutation, isDryRun, planInfo) {
+    const pr = nqlResult.planReport;
+    return {
+      sql: finalSql,
+      params: nqlResult.params,
+      intent: nqlResult.intent,
+      plan: {
+        strategy: isMutation ? `${nqlResult.intentType.toUpperCase()} - ${planInfo}` : "NQL v2",
+        rootTable: pr?.rootTable ?? "",
+        tables: [
+          ...new Set(
+            pr?.decisions.map((d) => d.context.sourceTable).filter(Boolean) ?? []
+          )
+        ],
+        decisions: pr?.decisions.map((d) => ({
+          type: d.type,
+          context: [d.context.sourceTable, d.context.target].filter(Boolean).join(" \u2192 "),
+          choice: d.choice,
+          reasoning: d.reasoning,
+          ...d.alternatives.length > 0 && {
+            alternatives: [...d.alternatives]
+          },
+          ...d.context.foreignKey !== void 0 && {
+            foreignKey: typeof d.context.foreignKey === "string" ? d.context.foreignKey : [...d.context.foreignKey]
+          },
+          ...d.context.relationType !== void 0 && {
+            relationType: d.context.relationType
+          },
+          ...d.context.intentPath !== void 0 && {
+            intentPath: d.context.intentPath
+          },
+          ...d.context.relationPath !== void 0 && {
+            relationPath: d.context.relationPath
+          },
+          ...d.id !== void 0 && { decisionId: d.id }
+        })) ?? [],
+        warnings: [
+          ...isDryRun ? [{ message: "This is a dry-run. Add ! suffix to execute." }] : [],
+          ...pr?.warnings.map((w) => ({
+            message: w.message,
+            ...w.suggestion !== void 0 && { suggestion: w.suggestion },
+            ...w.code !== void 0 && { code: w.code },
+            ...w.relatedDecision !== void 0 && {
+              relatedDecision: w.relatedDecision
+            }
+          })) ?? []
+        ],
+        cteCount: pr?.ctes.length ?? 0,
+        planningTimeMs: pr?.metadata.planningTimeMs ?? 0,
+        ...pr?.ctes && pr.ctes.length > 0 ? {
+          ctes: pr.ctes.map((c) => ({
+            name: c.name,
+            purpose: c.purpose,
+            ...c.recursive && { recursive: c.recursive },
+            ...c.referencedBy.length > 0 && {
+              referencedBy: [...c.referencedBy]
+            }
+          }))
+        } : {},
+        ...pr?.metadata ? {
+          metadata: {
+            relationsAnalyzed: pr.metadata.relationsAnalyzed,
+            isAmbiguous: pr.metadata.isAmbiguous,
+            ...pr.metadata.ambiguousOptions && pr.metadata.ambiguousOptions.length > 0 && {
+              ambiguousOptions: [...pr.metadata.ambiguousOptions]
+            }
+          }
+        } : {}
+      }
+    };
+  }
+  shouldExecuteQuery(isMutation, isDryRun) {
+    return isMutation ? !isDryRun && this.state.execMode && this.state.connected : this.state.execMode && this.state.connected;
+  }
+};
+
+export {
+  getDatabaseName,
+  processDotCommand,
+  ReplEngine
+};
+//# sourceMappingURL=chunk-ZSGVJFWG.js.map