midql-cli 0.1.0

package/dist/chunk-WN6T44OZ.js

@@ -0,0 +1,1643 @@
+#!/usr/bin/env node
+import {
+  ConnectionManager
+} from "./chunk-3CIK5I4M.js";
+import {
+  formatResultSet
+} from "./chunk-7WNCISNV.js";
+import {
+  historyFilePath,
+  loadConfig
+} from "./chunk-3QAR6XBK.js";
+import {
+  AmbiguityError,
+  MidqlError,
+  ParseError
+} from "./chunk-VFC3HWTF.js";
+
+// src/nl/clauses.ts
+var limitWords = /* @__PURE__ */ new Set(["first", "top", "limit", "last"]);
+var sortWords = /* @__PURE__ */ new Set(["sorted", "ordered", "sort", "order"]);
+var conditionIntros = /* @__PURE__ */ new Set([
+  "where",
+  "which",
+  "that",
+  "who",
+  "whose",
+  "having",
+  "has",
+  "have",
+  "with"
+]);
+function extractClauses(tokens) {
+  const subject = [];
+  const conditionTokens = [];
+  const sortTokens = [];
+  let limit = null;
+  let reverse = false;
+  let mode = "subject";
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    const next = tokens[index + 1];
+    if (token.type === "word" && limitWords.has(token.value) && next?.type === "number") {
+      limit = Number(next.value);
+      if (token.value === "last") {
+        reverse = true;
+      }
+      index += 2;
+      continue;
+    }
+    if (token.type === "word" && sortWords.has(token.value) && next?.type === "word" && next.value === "by") {
+      mode = "sort";
+      index += 2;
+      continue;
+    }
+    if (mode === "subject" && token.type === "word" && conditionIntros.has(token.value)) {
+      mode = "conditions";
+      index += 1;
+      continue;
+    }
+    if (mode === "subject") {
+      subject.push(token);
+    } else if (mode === "conditions") {
+      conditionTokens.push(token);
+    } else {
+      sortTokens.push(token);
+    }
+    index += 1;
+  }
+  return { subject, conditionTokens, sortTokens, limit, reverse };
+}
+
+// src/nl/fuzzy.ts
+import pluralize from "pluralize";
+var ACCEPT_THRESHOLD = 0.72;
+var AMBIGUITY_GAP = 0.08;
+function normalizeIdentifier(value) {
+  return value.toLowerCase().replace(/[_\s-]/g, "");
+}
+function damerauLevenshtein(a, b) {
+  if (a === b) {
+    return 0;
+  }
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  const matrix = Array.from({ length: rows }, () => new Array(cols).fill(0));
+  for (let i = 0; i < rows; i++) {
+    matrix[i][0] = i;
+  }
+  for (let j = 0; j < cols; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i < rows; i++) {
+    for (let j = 1; j < cols; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      let value = Math.min(
+        matrix[i - 1][j] + 1,
+        matrix[i][j - 1] + 1,
+        matrix[i - 1][j - 1] + cost
+      );
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        value = Math.min(value, matrix[i - 2][j - 2] + 1);
+      }
+      matrix[i][j] = value;
+    }
+  }
+  return matrix[a.length][b.length];
+}
+function similarity(a, b) {
+  const longest = Math.max(a.length, b.length);
+  if (longest === 0) {
+    return 1;
+  }
+  return 1 - damerauLevenshtein(a, b) / longest;
+}
+function scoreName(input, candidate) {
+  const inputLower = input.toLowerCase();
+  const candidateLower = candidate.toLowerCase();
+  if (inputLower === candidateLower) {
+    return 1;
+  }
+  if (pluralize.singular(inputLower) === pluralize.singular(candidateLower) || pluralize.plural(inputLower) === candidateLower || pluralize.singular(inputLower) === candidateLower) {
+    return 0.95;
+  }
+  const inputNorm = normalizeIdentifier(input);
+  const candidateNorm = normalizeIdentifier(candidate);
+  if (inputNorm === candidateNorm) {
+    return 0.9;
+  }
+  if (pluralize.singular(inputNorm) === pluralize.singular(candidateNorm) && inputNorm.length > 2) {
+    return 0.88;
+  }
+  if (candidateNorm.startsWith(inputNorm) && inputNorm.length >= 3) {
+    return 0.8;
+  }
+  const base = similarity(pluralize.singular(inputNorm), pluralize.singular(candidateNorm));
+  return Math.min(base, 0.79);
+}
+function rankCandidates(input, candidates, nameOf) {
+  return candidates.map((item) => ({ item, score: scoreName(input, nameOf(item)) })).sort((a, b) => b.score - a.score);
+}
+
+// src/nl/entities.ts
+function findTable(name, schema) {
+  const ranked = rankCandidates(name, schema.tables, (table) => table.name);
+  const best = ranked[0];
+  if (!best || best.score < ACCEPT_THRESHOLD) {
+    return null;
+  }
+  return best.item;
+}
+function resolveTable(name, schema) {
+  const ranked = rankCandidates(name, schema.tables, (table) => table.name);
+  const best = ranked[0];
+  if (!best || best.score < ACCEPT_THRESHOLD) {
+    const nearest = ranked.slice(0, 3).filter((match) => match.score > 0.4);
+    throw new ParseError(`No table matching "${name}"`, {
+      suggestions: nearest.map((match) => match.item.name)
+    });
+  }
+  const second = ranked[1];
+  if (second && second.score >= ACCEPT_THRESHOLD && best.score - second.score < AMBIGUITY_GAP) {
+    throw new AmbiguityError(
+      name,
+      ranked.filter((match) => best.score - match.score < AMBIGUITY_GAP).map((match) => ({
+        value: match.item.name,
+        label: match.item.name,
+        detail: `table with ${match.item.columns.length} columns`
+      }))
+    );
+  }
+  return best.item;
+}
+function resolveTableFromTokens(tokens, startIndex, schema) {
+  const first = tokens[startIndex];
+  if (!first || first.type !== "word") {
+    throw new ParseError("Expected a table name", {
+      suggestions: schema.tables.slice(0, 3).map((table) => table.name)
+    });
+  }
+  const second = tokens[startIndex + 1];
+  if (second && second.type === "word") {
+    const combined = `${first.value}_${second.value}`;
+    const table = findTable(combined, schema);
+    if (table) {
+      return { table, consumed: 2 };
+    }
+  }
+  return { table: resolveTable(first.value, schema), consumed: 1 };
+}
+function resolveColumn(name, baseTable, schema) {
+  if (name.includes(".")) {
+    const [tablePart, columnPart] = name.split(".", 2);
+    const table = resolveTable(tablePart, schema);
+    const ranked2 = rankCandidates(columnPart, table.columns, (column) => column.name);
+    const best2 = ranked2[0];
+    if (!best2 || best2.score < ACCEPT_THRESHOLD) {
+      throw new ParseError(`No column matching "${columnPart}" in ${table.name}`, {
+        suggestions: ranked2.slice(0, 3).map((match) => match.item.name)
+      });
+    }
+    return {
+      tableName: table.name,
+      column: best2.item,
+      requiresJoin: table.name !== baseTable.name
+    };
+  }
+  const candidates = [];
+  for (const table of schema.tables) {
+    for (const column of table.columns) {
+      candidates.push({ tableName: table.name, column, base: table.name === baseTable.name });
+    }
+  }
+  const ranked = rankCandidates(name, candidates, (candidate) => candidate.column.name).map(
+    (match) => ({
+      ...match,
+      score: match.score + (match.item.base ? 0.05 : 0)
+    })
+  );
+  ranked.sort((a, b) => b.score - a.score);
+  const best = ranked[0];
+  if (!best || best.score < ACCEPT_THRESHOLD) {
+    const nearest = ranked.slice(0, 3).filter((match) => match.score > 0.4);
+    throw new ParseError(`No column matching "${name}"`, {
+      suggestions: nearest.map((match) => `${match.item.tableName}.${match.item.column.name}`)
+    });
+  }
+  if (!best.item.base) {
+    const contenders = ranked.filter(
+      (match) => match !== best && best.score - match.score < AMBIGUITY_GAP && match.score >= ACCEPT_THRESHOLD && match.item.tableName !== best.item.tableName
+    );
+    if (contenders.length > 0) {
+      throw new AmbiguityError(name, [
+        {
+          value: `${best.item.tableName}.${best.item.column.name}`,
+          label: `${best.item.tableName}.${best.item.column.name}`,
+          detail: best.item.column.dataType
+        },
+        ...contenders.map((match) => ({
+          value: `${match.item.tableName}.${match.item.column.name}`,
+          label: `${match.item.tableName}.${match.item.column.name}`,
+          detail: match.item.column.dataType
+        }))
+      ]);
+    }
+  }
+  return {
+    tableName: best.item.tableName,
+    column: best.item.column,
+    requiresJoin: best.item.tableName !== baseTable.name
+  };
+}
+function resolveColumnInTable(name, table) {
+  const ranked = rankCandidates(name, table.columns, (column) => column.name);
+  const best = ranked[0];
+  if (!best || best.score < ACCEPT_THRESHOLD) {
+    throw new ParseError(`No column matching "${name}" in ${table.name}`, {
+      suggestions: ranked.slice(0, 3).map((match) => match.item.name)
+    });
+  }
+  return best.item;
+}
+
+// src/nl/conditions.ts
+var operatorRules = [
+  { words: ["is", "not", "null"], operator: "isNotNull" },
+  { words: ["is", "not", "empty"], operator: "isNotNull" },
+  { words: ["is", "null"], operator: "isNull" },
+  { words: ["is", "empty"], operator: "isNull" },
+  { words: ["is", "set"], operator: "isNotNull" },
+  { words: ["exists"], operator: "isNotNull" },
+  { words: ["greater", "than", "or", "equal", "to"], operator: ">=" },
+  { words: ["less", "than", "or", "equal", "to"], operator: "<=" },
+  { words: ["greater", "than"], operator: ">" },
+  { words: ["more", "than"], operator: ">" },
+  { words: ["bigger", "than"], operator: ">" },
+  { words: ["higher", "than"], operator: ">" },
+  { words: ["less", "than"], operator: "<" },
+  { words: ["fewer", "than"], operator: "<" },
+  { words: ["lower", "than"], operator: "<" },
+  { words: ["smaller", "than"], operator: "<" },
+  { words: ["at", "least"], operator: ">=" },
+  { words: ["at", "most"], operator: "<=" },
+  { words: ["over"], operator: ">" },
+  { words: ["above"], operator: ">" },
+  { words: ["under"], operator: "<" },
+  { words: ["below"], operator: "<" },
+  { words: ["is", "not"], operator: "!=" },
+  { words: ["not"], operator: "!=" },
+  { words: ["equal", "to"], operator: "=" },
+  { words: ["equals"], operator: "=" },
+  { words: ["is"], operator: "=" },
+  { words: ["contains"], operator: "ilike", pattern: "contains" },
+  { words: ["containing"], operator: "ilike", pattern: "contains" },
+  { words: ["includes"], operator: "ilike", pattern: "contains" },
+  { words: ["including"], operator: "ilike", pattern: "contains" },
+  { words: ["like"], operator: "ilike", pattern: "contains" },
+  { words: ["starts", "with"], operator: "ilike", pattern: "startsWith" },
+  { words: ["begins", "with"], operator: "ilike", pattern: "startsWith" },
+  { words: ["starting", "with"], operator: "ilike", pattern: "startsWith" },
+  { words: ["ends", "with"], operator: "ilike", pattern: "endsWith" },
+  { words: ["ending", "with"], operator: "ilike", pattern: "endsWith" },
+  { words: ["between"], operator: "between" },
+  { words: ["in"], operator: "in" }
+];
+var skippableWords = /* @__PURE__ */ new Set(["has", "have", "had", "that", "who", "whose", "with", "value"]);
+function isValueToken(token) {
+  return token !== void 0 && (token.type === "number" || token.type === "string" || token.type === "word");
+}
+function coerceValue(token, kind) {
+  if (token.type === "number") {
+    return Number(token.value);
+  }
+  if (token.type === "string") {
+    return token.value;
+  }
+  const word = token.value;
+  if (kind === "boolean" || word === "true" || word === "false") {
+    if (["true", "yes", "on"].includes(word)) {
+      return true;
+    }
+    if (["false", "no", "off"].includes(word)) {
+      return false;
+    }
+  }
+  if (word === "null" || word === "nothing" || word === "none") {
+    return null;
+  }
+  if (kind === "number" && /^-?\d+(\.\d+)?$/.test(word)) {
+    return Number(word);
+  }
+  return token.raw;
+}
+function applyPattern(value, pattern) {
+  if (typeof value !== "string" || !pattern) {
+    return value;
+  }
+  if (pattern === "contains") {
+    return `%${value}%`;
+  }
+  if (pattern === "startsWith") {
+    return `${value}%`;
+  }
+  return `%${value}`;
+}
+function matchOperator(tokens, index) {
+  const first = tokens[index];
+  if (!first) {
+    return null;
+  }
+  if (first.type === "operator") {
+    return {
+      rule: { words: [], operator: first.value },
+      consumed: 1
+    };
+  }
+  for (const rule of operatorRules) {
+    const matches = rule.words.every((word, offset) => {
+      const token = tokens[index + offset];
+      return token?.type === "word" && token.value === word;
+    });
+    if (matches && rule.words.length > 0) {
+      return { rule, consumed: rule.words.length };
+    }
+  }
+  return null;
+}
+function parseConditions(tokens, baseTable, schema) {
+  if (tokens.length === 0) {
+    return { where: null, foreignTables: [] };
+  }
+  const foreignTables = /* @__PURE__ */ new Set();
+  const conditions = [];
+  const connectors = [];
+  let index = 0;
+  while (index < tokens.length) {
+    while (tokens[index]?.type === "word" && skippableWords.has(tokens[index].value)) {
+      index += 1;
+    }
+    const columnToken = tokens[index];
+    if (!columnToken || columnToken.type !== "word") {
+      throw new ParseError("Expected a column name in the condition", {
+        position: columnToken?.position ?? tokens[tokens.length - 1]?.position
+      });
+    }
+    const resolved = resolveColumn(columnToken.value, baseTable, schema);
+    if (resolved.requiresJoin) {
+      foreignTables.add(resolved.tableName);
+    }
+    index += 1;
+    const operatorMatch = matchOperator(tokens, index);
+    let operator = "=";
+    let pattern;
+    if (operatorMatch) {
+      operator = operatorMatch.rule.operator;
+      pattern = operatorMatch.rule.pattern;
+      index += operatorMatch.consumed;
+    }
+    const columnRef = { table: resolved.tableName, column: resolved.column.name };
+    if (operator === "isNull" || operator === "isNotNull") {
+      conditions.push({ type: "condition", column: columnRef, operator, values: [] });
+    } else if (operator === "between") {
+      const low = tokens[index];
+      const connector = tokens[index + 1];
+      const high = tokens[index + 2];
+      if (!isValueToken(low) || connector?.value !== "and" || !isValueToken(high)) {
+        throw new ParseError(`"between" needs two values joined by "and"`, {
+          position: low?.position
+        });
+      }
+      conditions.push({
+        type: "condition",
+        column: columnRef,
+        operator,
+        values: [coerceValue(low, resolved.column.kind), coerceValue(high, resolved.column.kind)]
+      });
+      index += 3;
+    } else if (operator === "in") {
+      const values = [];
+      while (isValueToken(tokens[index])) {
+        values.push(coerceValue(tokens[index], resolved.column.kind));
+        index += 1;
+        const separator = tokens[index];
+        if (separator?.type === "comma" || separator?.type === "word" && separator.value === "or") {
+          index += 1;
+        } else {
+          break;
+        }
+      }
+      if (values.length === 0) {
+        throw new ParseError(`"in" needs at least one value`, {
+          position: tokens[index]?.position
+        });
+      }
+      conditions.push({ type: "condition", column: columnRef, operator, values });
+    } else {
+      const valueToken = tokens[index];
+      if (!isValueToken(valueToken)) {
+        throw new ParseError(`Expected a value for "${resolved.column.name}"`, {
+          position: valueToken?.position ?? columnToken.position
+        });
+      }
+      const value = coerceValue(valueToken, resolved.column.kind);
+      if (value === null) {
+        conditions.push({
+          type: "condition",
+          column: columnRef,
+          operator: operator === "!=" ? "isNotNull" : "isNull",
+          values: []
+        });
+      } else {
+        conditions.push({
+          type: "condition",
+          column: columnRef,
+          operator,
+          values: [applyPattern(value, pattern)]
+        });
+      }
+      index += 1;
+    }
+    const connectorToken = tokens[index];
+    if (connectorToken?.type === "word" && (connectorToken.value === "and" || connectorToken.value === "or")) {
+      connectors.push(connectorToken.value);
+      index += 1;
+      continue;
+    }
+    if (connectorToken !== void 0 && connectorToken.type === "comma") {
+      connectors.push("and");
+      index += 1;
+      continue;
+    }
+    if (connectorToken !== void 0) {
+      throw new ParseError(`Unexpected "${connectorToken.raw}" in condition`, {
+        position: connectorToken.position
+      });
+    }
+  }
+  return { where: groupConditions(conditions, connectors), foreignTables: [...foreignTables] };
+}
+function groupConditions(conditions, connectors) {
+  if (conditions.length === 0) {
+    return null;
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  const orGroups = [[conditions[0]]];
+  connectors.forEach((connector, index) => {
+    const condition = conditions[index + 1];
+    if (!condition) {
+      return;
+    }
+    if (connector === "or") {
+      orGroups.push([condition]);
+    } else {
+      orGroups[orGroups.length - 1].push(condition);
+    }
+  });
+  const andNodes = orGroups.map(
+    (group) => group.length === 1 ? group[0] : { type: "group", combinator: "and", items: group }
+  );
+  if (andNodes.length === 1) {
+    return andNodes[0];
+  }
+  return { type: "group", combinator: "or", items: andNodes };
+}
+
+// src/nl/intent.ts
+var selectVerbs = /* @__PURE__ */ new Set([
+  "show",
+  "list",
+  "get",
+  "select",
+  "find",
+  "search",
+  "display",
+  "fetch",
+  "give",
+  "view"
+]);
+var insertVerbs = /* @__PURE__ */ new Set(["add", "insert", "register"]);
+var updateVerbs = /* @__PURE__ */ new Set(["update", "change", "modify", "set"]);
+var deleteVerbs = /* @__PURE__ */ new Set(["delete", "remove", "erase"]);
+var describeVerbs = /* @__PURE__ */ new Set(["describe", "desc", "inspect"]);
+var aggregateWords = /* @__PURE__ */ new Map([
+  ["average", "avg"],
+  ["avg", "avg"],
+  ["mean", "avg"],
+  ["sum", "sum"],
+  ["total", "sum"],
+  ["min", "min"],
+  ["minimum", "min"],
+  ["lowest", "min"],
+  ["smallest", "min"],
+  ["max", "max"],
+  ["maximum", "max"],
+  ["highest", "max"],
+  ["largest", "max"],
+  ["biggest", "max"]
+]);
+var allVerbs = [
+  ...selectVerbs,
+  ...insertVerbs,
+  ...updateVerbs,
+  ...deleteVerbs,
+  ...describeVerbs,
+  ...aggregateWords.keys(),
+  "count",
+  "create",
+  "drop",
+  "how",
+  "what"
+];
+function isTablesWord(token) {
+  return token?.type === "word" && (token.value === "tables" || token.value === "table");
+}
+function classifyIntent(tokens) {
+  const first = tokens[0];
+  if (!first || first.type !== "word") {
+    throw new ParseError("Could not understand the input", {
+      suggestions: ["show all users", "count orders", "\\help"]
+    });
+  }
+  const second = tokens[1];
+  const rest = tokens.slice(1);
+  if ((selectVerbs.has(first.value) || first.value === "what") && isTablesWord(second) && tokens.length <= 3) {
+    return { intent: "showTables", tokens: [], aggregate: null };
+  }
+  if (first.value === "tables" && tokens.length === 1) {
+    return { intent: "showTables", tokens: [], aggregate: null };
+  }
+  if (describeVerbs.has(first.value)) {
+    return { intent: "describe", tokens: rest, aggregate: null };
+  }
+  if (first.value === "what") {
+    const inIndex = tokens.findIndex((token) => token.type === "word" && token.value === "in");
+    if (inIndex >= 0) {
+      return { intent: "describe", tokens: tokens.slice(inIndex + 1), aggregate: null };
+    }
+    throw new ParseError(`Could not understand "what ..." \u2014 try "what is in <table>"`);
+  }
+  if (selectVerbs.has(first.value) && second?.type === "word" && second.value === "columns") {
+    const ofIndex = tokens.findIndex(
+      (token, index) => index > 1 && token.type === "word" && (token.value === "of" || token.value === "in" || token.value === "from")
+    );
+    return {
+      intent: "describe",
+      tokens: ofIndex >= 0 ? tokens.slice(ofIndex + 1) : tokens.slice(2),
+      aggregate: null
+    };
+  }
+  if (first.value === "count") {
+    return { intent: "count", tokens: rest, aggregate: null };
+  }
+  if (first.value === "how" && second?.type === "word" && second.value === "many") {
+    return { intent: "count", tokens: tokens.slice(2), aggregate: null };
+  }
+  const aggregate = aggregateWords.get(first.value);
+  if (aggregate) {
+    return { intent: "aggregate", tokens: rest, aggregate };
+  }
+  if (first.value === "create") {
+    if (isTablesWord(second)) {
+      return { intent: "createTable", tokens: tokens.slice(2), aggregate: null };
+    }
+    return { intent: "insert", tokens: rest, aggregate: null };
+  }
+  if (first.value === "drop") {
+    return {
+      intent: "dropTable",
+      tokens: isTablesWord(second) ? tokens.slice(2) : rest,
+      aggregate: null
+    };
+  }
+  if (deleteVerbs.has(first.value)) {
+    if (isTablesWord(second) && tokens.length === 3) {
+      return { intent: "dropTable", tokens: tokens.slice(2), aggregate: null };
+    }
+    return { intent: "delete", tokens: rest, aggregate: null };
+  }
+  if (insertVerbs.has(first.value)) {
+    return { intent: "insert", tokens: rest, aggregate: null };
+  }
+  if (updateVerbs.has(first.value)) {
+    return { intent: "update", tokens: rest, aggregate: null };
+  }
+  if (selectVerbs.has(first.value)) {
+    return { intent: "select", tokens: rest, aggregate: null };
+  }
+  const nearest = rankCandidates(first.value, allVerbs, (verb) => verb).slice(0, 3).filter((match) => match.score > 0.5).map((match) => match.item);
+  throw new ParseError(`Don't know how to "${first.raw}"`, {
+    position: first.position,
+    suggestions: nearest.length > 0 ? nearest : ["show", "count", "add", "update", "delete"]
+  });
+}
+
+// src/nl/joins.ts
+function buildFkGraph(schema) {
+  const graph = /* @__PURE__ */ new Map();
+  const add = (edge) => {
+    const edges = graph.get(edge.from) ?? [];
+    edges.push(edge);
+    graph.set(edge.from, edges);
+  };
+  for (const table of schema.tables) {
+    for (const fk of table.foreignKeys) {
+      const fromColumn = fk.columns[0];
+      const toColumn = fk.referencedColumns[0];
+      if (!fromColumn || !toColumn) {
+        continue;
+      }
+      add({ from: table.name, to: fk.referencedTable, fromColumn, toColumn });
+      add({ from: fk.referencedTable, to: table.name, fromColumn: toColumn, toColumn: fromColumn });
+    }
+  }
+  return graph;
+}
+function describePath(base, path) {
+  return [base, ...path.map((edge) => `${edge.to} (on ${edge.from}.${edge.fromColumn})`)].join(
+    " \u2192 "
+  );
+}
+function findJoinPath(baseTable, targetTable, schema, maxDepth) {
+  if (baseTable === targetTable) {
+    return [];
+  }
+  const graph = buildFkGraph(schema);
+  let frontier = [{ table: baseTable, path: [] }];
+  const visitedDepth = /* @__PURE__ */ new Map([[baseTable, 0]]);
+  for (let depth = 1; depth <= maxDepth; depth++) {
+    const next = [];
+    const arrivals = [];
+    for (const state of frontier) {
+      for (const edge of graph.get(state.table) ?? []) {
+        const known = visitedDepth.get(edge.to);
+        if (known !== void 0 && known < depth) {
+          continue;
+        }
+        visitedDepth.set(edge.to, depth);
+        const extended = { table: edge.to, path: [...state.path, edge] };
+        if (edge.to === targetTable) {
+          arrivals.push(extended);
+        } else {
+          next.push(extended);
+        }
+      }
+    }
+    if (arrivals.length > 0) {
+      const unique = new Map(arrivals.map((state) => [describePath(baseTable, state.path), state]));
+      if (unique.size > 1) {
+        throw new AmbiguityError(
+          targetTable,
+          [...unique.values()].map((state) => ({
+            value: describePath(baseTable, state.path),
+            label: describePath(baseTable, state.path),
+            detail: `${state.path.length} join${state.path.length === 1 ? "" : "s"}`
+          }))
+        );
+      }
+      return pathToJoins(arrivals[0].path);
+    }
+    frontier = next;
+    if (frontier.length === 0) {
+      break;
+    }
+  }
+  throw new ParseError(
+    `No relationship found between "${baseTable}" and "${targetTable}" within ${maxDepth} joins`,
+    { suggestions: [`\\d ${baseTable}`, `\\d ${targetTable}`, "write the join in raw SQL"] }
+  );
+}
+function pathToJoins(path) {
+  return path.map((edge) => ({
+    table: edge.to,
+    leftColumn: { table: edge.from, column: edge.fromColumn },
+    rightColumn: { table: edge.to, column: edge.toColumn }
+  }));
+}
+function resolveJoins(baseTable, foreignTables, schema, maxDepth) {
+  const joins = [];
+  const joined = /* @__PURE__ */ new Set([baseTable]);
+  for (const target of foreignTables) {
+    if (joined.has(target)) {
+      continue;
+    }
+    for (const join of findJoinPath(baseTable, target, schema, maxDepth)) {
+      if (!joined.has(join.table)) {
+        joins.push(join);
+        joined.add(join.table);
+      }
+    }
+  }
+  return joins;
+}
+
+// src/nl/subject.ts
+function splitSubject(subject) {
+  const connectorIndex = subject.findIndex(
+    (token) => token.type === "word" && (token.value === "of" || token.value === "from")
+  );
+  if (connectorIndex < 0) {
+    return { columnTokens: [], tableTokens: subject };
+  }
+  return {
+    columnTokens: subject.slice(0, connectorIndex),
+    tableTokens: subject.slice(connectorIndex + 1)
+  };
+}
+function parseColumnList(tokens, table) {
+  const refs = [];
+  for (const token of tokens) {
+    if (token.type === "comma" || token.type === "word" && token.value === "and") {
+      continue;
+    }
+    if (token.type !== "word") {
+      throw new ParseError(`Expected a column name, got "${token.raw}"`, {
+        position: token.position
+      });
+    }
+    const column = resolveColumnInTable(token.value, table);
+    refs.push({ table: table.name, column: column.name });
+  }
+  return refs;
+}
+var nameLikeColumns = ["name", "title", "username", "email", "label", "slug"];
+function nameLikeCondition(table, token) {
+  if (token.type === "number") {
+    const pk = table.primaryKey[0];
+    if (!pk) {
+      throw new ParseError(
+        `"${table.name}" has no primary key; use an explicit condition like "where id ${token.value}"`
+      );
+    }
+    return {
+      type: "condition",
+      column: { table: table.name, column: pk },
+      operator: "=",
+      values: [Number(token.value)]
+    };
+  }
+  const column = table.columns.find((candidate) => nameLikeColumns.includes(candidate.name)) ?? table.columns.find((candidate) => candidate.kind === "text" && !candidate.isPrimaryKey);
+  if (!column) {
+    throw new ParseError(
+      `Can't guess which column "${token.raw}" refers to in ${table.name}; use "where <column> is ${token.raw}"`
+    );
+  }
+  const value = token.type === "string" ? token.value : token.raw;
+  return {
+    type: "condition",
+    column: { table: table.name, column: column.name },
+    operator: "=",
+    values: [value]
+  };
+}
+function mergeWhere(existing, extra) {
+  if (!existing) {
+    return extra;
+  }
+  if (!extra) {
+    return existing;
+  }
+  return { type: "group", combinator: "and", items: [existing, extra] };
+}
+
+// src/nl/mutations.ts
+var assignmentConnectors = /* @__PURE__ */ new Set(["is", "as", "to", "of"]);
+var conditionIntros2 = /* @__PURE__ */ new Set(["where", "which", "that", "whose", "having"]);
+function isValueToken2(token) {
+  return token !== void 0 && (token.type === "number" || token.type === "string" || token.type === "word");
+}
+function parseAssignments(tokens, table) {
+  const values = {};
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (token.type === "comma" || token.type === "word" && token.value === "and") {
+      index += 1;
+      continue;
+    }
+    if (token.type === "word" && conditionIntros2.has(token.value)) {
+      break;
+    }
+    if (token.type !== "word") {
+      throw new ParseError(`Expected a column name, got "${token.raw}"`, {
+        position: token.position
+      });
+    }
+    const columnName = token.value === "named" ? "name" : token.value;
+    const column = resolveColumnInTable(columnName, table);
+    index += 1;
+    const connector = tokens[index];
+    if (connector && (connector.type === "operator" && connector.value === "=" || connector.type === "word" && assignmentConnectors.has(connector.value))) {
+      index += 1;
+    }
+    const valueToken = tokens[index];
+    if (!isValueToken2(valueToken)) {
+      throw new ParseError(`Expected a value for "${column.name}"`, {
+        position: token.position
+      });
+    }
+    values[column.name] = coerceValue(valueToken, column.kind);
+    index += 1;
+  }
+  if (Object.keys(values).length === 0) {
+    throw new ParseError(`Expected column/value pairs, e.g. "name john and rank 5"`);
+  }
+  return { values, consumed: index };
+}
+function parseInsert(tokens, schema) {
+  let index = 0;
+  if (tokens[index]?.type === "word" && tokens[index].value === "into") {
+    index += 1;
+  }
+  const { table, consumed } = resolveTableFromTokens(tokens, index, schema);
+  index += consumed;
+  const introducer = tokens[index];
+  if (introducer?.type === "word" && (introducer.value === "with" || introducer.value === "values" || introducer.value === "set")) {
+    index += 1;
+  }
+  const { values } = parseAssignments(tokens.slice(index), table);
+  return { kind: "insert", table: table.name, values };
+}
+function parseUpdate(tokens, schema, maxJoinDepth) {
+  const ofIndex = tokens.findIndex((token) => token.type === "word" && token.value === "of");
+  const setIndex = tokens.findIndex((token) => token.type === "word" && token.value === "set");
+  if (ofIndex > 0 && (setIndex < 0 || ofIndex < setIndex)) {
+    return parseColumnFirstUpdate(tokens, ofIndex, schema, maxJoinDepth);
+  }
+  const { table, consumed } = resolveTableFromTokens(tokens, 0, schema);
+  let index = consumed;
+  if (tokens[index]?.type === "word" && tokens[index].value === "set") {
+    index += 1;
+  }
+  const rest = tokens.slice(index);
+  const { values, consumed: assignmentConsumed } = parseAssignments(rest, table);
+  const conditionTokens = stripConditionIntro(rest.slice(assignmentConsumed));
+  const parsed = parseConditions(conditionTokens, table, schema);
+  return {
+    kind: "update",
+    table: table.name,
+    set: values,
+    joins: resolveJoins(table.name, parsed.foreignTables, schema, maxJoinDepth),
+    where: parsed.where,
+    keyColumn: table.primaryKey[0] ?? null
+  };
+}
+function parseColumnFirstUpdate(tokens, ofIndex, schema, maxJoinDepth) {
+  const columnToken = tokens[ofIndex - 1];
+  if (!columnToken || columnToken.type !== "word") {
+    throw new ParseError(`Expected a column before "of"`, { position: tokens[ofIndex]?.position });
+  }
+  const { table, consumed } = resolveTableFromTokens(tokens, ofIndex + 1, schema);
+  const column = resolveColumnInTable(columnToken.value, table);
+  let index = ofIndex + 1 + consumed;
+  let bareCondition = null;
+  const maybeBare = tokens[index];
+  if (isValueToken2(maybeBare) && !(maybeBare.type === "word" && maybeBare.value === "to")) {
+    bareCondition = nameLikeCondition(table, maybeBare);
+    index += 1;
+  }
+  const toToken = tokens[index];
+  if (!(toToken?.type === "word" && toToken.value === "to") && !(toToken?.type === "operator" && toToken.value === "=")) {
+    throw new ParseError(`Expected "to <value>" after the column`, {
+      position: toToken?.position ?? columnToken.position
+    });
+  }
+  index += 1;
+  const valueToken = tokens[index];
+  if (!isValueToken2(valueToken)) {
+    throw new ParseError(`Expected a value after "to"`, { position: toToken.position });
+  }
+  index += 1;
+  const conditionTokens = stripConditionIntro(tokens.slice(index));
+  const parsed = parseConditions(conditionTokens, table, schema);
+  return {
+    kind: "update",
+    table: table.name,
+    set: { [column.name]: coerceValue(valueToken, column.kind) },
+    joins: resolveJoins(table.name, parsed.foreignTables, schema, maxJoinDepth),
+    where: mergeWhere(bareCondition, parsed.where),
+    keyColumn: table.primaryKey[0] ?? null
+  };
+}
+function stripConditionIntro(tokens) {
+  const first = tokens[0];
+  if (first?.type === "word" && (conditionIntros2.has(first.value) || first.value === "with")) {
+    return tokens.slice(1);
+  }
+  return tokens;
+}
+function parseDelete(tokens, schema, maxJoinDepth) {
+  const clauses = extractClauses(tokens);
+  const { table, consumed } = resolveTableFromTokens(clauses.subject, 0, schema);
+  const leftover = clauses.subject[consumed];
+  const bareCondition = isValueToken2(leftover) ? nameLikeCondition(table, leftover) : null;
+  const parsed = parseConditions(clauses.conditionTokens, table, schema);
+  return {
+    kind: "delete",
+    table: table.name,
+    joins: resolveJoins(table.name, parsed.foreignTables, schema, maxJoinDepth),
+    where: mergeWhere(bareCondition, parsed.where),
+    keyColumn: table.primaryKey[0] ?? null
+  };
+}
+var typeWords = /* @__PURE__ */ new Map([
+  ["text", "text"],
+  ["string", "text"],
+  ["varchar", "text"],
+  ["number", "number"],
+  ["int", "number"],
+  ["integer", "number"],
+  ["decimal", "decimal"],
+  ["float", "decimal"],
+  ["double", "decimal"],
+  ["money", "decimal"],
+  ["numeric", "decimal"],
+  ["bool", "boolean"],
+  ["boolean", "boolean"],
+  ["date", "date"],
+  ["timestamp", "timestamp"],
+  ["datetime", "timestamp"],
+  ["time", "timestamp"],
+  ["json", "json"],
+  ["uuid", "uuid"],
+  ["serial", "serial"]
+]);
+function referencedType(kind) {
+  if (kind === "uuid") {
+    return "uuid";
+  }
+  if (kind === "text") {
+    return "text";
+  }
+  return "number";
+}
+function parseCreateTable(tokens, schema) {
+  const nameToken = tokens[0];
+  if (!nameToken || nameToken.type !== "word" || !/^[a-z_][\w]*$/i.test(nameToken.raw)) {
+    throw new ParseError('Expected a valid table name after "create table"');
+  }
+  let index = 1;
+  if (tokens[index]?.type === "word" && tokens[index].value === "with") {
+    index += 1;
+  }
+  const columns = [];
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (token.type === "comma" || token.type === "word" && token.value === "and") {
+      index += 1;
+      continue;
+    }
+    if (token.type !== "word") {
+      throw new ParseError(`Expected a column name, got "${token.raw}"`, {
+        position: token.position
+      });
+    }
+    const columnName = token.value;
+    index += 1;
+    const specifier = tokens[index];
+    if (specifier?.type === "word" && specifier.value === "references") {
+      const targetToken = tokens[index + 1];
+      if (!targetToken || targetToken.type !== "word") {
+        throw new ParseError(`Expected a table after "references"`, {
+          position: specifier.position
+        });
+      }
+      const target = resolveTable(targetToken.value, schema);
+      const referencedColumn = target.primaryKey[0] ?? "id";
+      const referenced = target.columns.find((column) => column.name === referencedColumn);
+      columns.push({
+        name: columnName,
+        type: referenced ? referencedType(referenced.kind) : "number",
+        nullable: true,
+        references: { table: target.name, column: referencedColumn }
+      });
+      index += 2;
+      continue;
+    }
+    if (specifier?.type === "word" && typeWords.has(specifier.value)) {
+      columns.push({
+        name: columnName,
+        type: typeWords.get(specifier.value),
+        nullable: true,
+        references: null
+      });
+      index += 1;
+      continue;
+    }
+    throw new ParseError(
+      `Expected a type for "${columnName}" (text, number, decimal, boolean, date, timestamp, json, uuid) or "references <table>"`,
+      { position: specifier?.position ?? token.position }
+    );
+  }
+  if (columns.length === 0) {
+    throw new ParseError(
+      `Expected column definitions, e.g. "create table pets with name text, age number, owner references users"`
+    );
+  }
+  if (!columns.some((column) => column.name === "id")) {
+    columns.unshift({ name: "id", type: "serial", nullable: false, references: null });
+  }
+  return { kind: "createTable", table: nameToken.raw, columns };
+}
+function parseDropTable(tokens, schema) {
+  const nameToken = tokens[0];
+  if (!nameToken || nameToken.type !== "word") {
+    throw new ParseError(`Expected a table name after "drop table"`);
+  }
+  const table = resolveTable(nameToken.value, schema);
+  return { kind: "dropTable", table: table.name };
+}
+
+// src/nl/tokenizer.ts
+var operatorPattern = /^(>=|<=|!=|<>|=|>|<)/;
+var datePattern = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2})?)?/;
+var numberPattern = /^-?\d+(?:\.\d+)?(?![\w-])/;
+var wordPattern = /^[\w.]+/;
+function tokenize(input) {
+  const tokens = [];
+  let index = 0;
+  while (index < input.length) {
+    const char = input[index];
+    if (/\s/.test(char)) {
+      index += 1;
+      continue;
+    }
+    const rest = input.slice(index);
+    if (char === "'" || char === '"') {
+      const closing = input.indexOf(char, index + 1);
+      const end = closing === -1 ? input.length : closing;
+      const value = input.slice(index + 1, end);
+      tokens.push({ type: "string", value, raw: input.slice(index, end + 1), position: index });
+      index = end + 1;
+      continue;
+    }
+    if (char === ",") {
+      tokens.push({ type: "comma", value: ",", raw: ",", position: index });
+      index += 1;
+      continue;
+    }
+    const operatorMatch = operatorPattern.exec(rest);
+    if (operatorMatch) {
+      const value = operatorMatch[0] === "<>" ? "!=" : operatorMatch[0];
+      tokens.push({ type: "operator", value, raw: operatorMatch[0], position: index });
+      index += operatorMatch[0].length;
+      continue;
+    }
+    const dateMatch = datePattern.exec(rest);
+    if (dateMatch) {
+      tokens.push({ type: "string", value: dateMatch[0], raw: dateMatch[0], position: index });
+      index += dateMatch[0].length;
+      continue;
+    }
+    const numberMatch = numberPattern.exec(rest);
+    if (numberMatch) {
+      tokens.push({ type: "number", value: numberMatch[0], raw: numberMatch[0], position: index });
+      index += numberMatch[0].length;
+      continue;
+    }
+    const wordMatch = wordPattern.exec(rest);
+    if (wordMatch) {
+      tokens.push({
+        type: "word",
+        value: wordMatch[0].toLowerCase(),
+        raw: wordMatch[0],
+        position: index
+      });
+      index += wordMatch[0].length;
+      continue;
+    }
+    index += 1;
+  }
+  return tokens;
+}
+var fillerWords = /* @__PURE__ */ new Set(["the", "a", "an", "me", "please", "all", "every", "new"]);
+function dropFillers(tokens) {
+  return tokens.filter((token) => token.type !== "word" || !fillerWords.has(token.value));
+}
+
+// src/nl/translate.ts
+var defaultOptions = { maxJoinDepth: 3 };
+function translate(input, schema, options) {
+  const { maxJoinDepth } = { ...defaultOptions, ...options };
+  const tokens = dropFillers(tokenize(input));
+  if (tokens.length === 0) {
+    throw new ParseError("Empty input");
+  }
+  const classified = classifyIntent(tokens);
+  switch (classified.intent) {
+    case "showTables":
+      return { kind: "showTables" };
+    case "describe":
+      return parseDescribe(classified.tokens, schema);
+    case "select":
+      return parseSelect(classified.tokens, schema, maxJoinDepth, null);
+    case "count":
+      return parseSelect(classified.tokens, schema, maxJoinDepth, {
+        fn: "count",
+        column: null
+      });
+    case "aggregate":
+      return parseAggregate(classified.tokens, classified.aggregate, schema, maxJoinDepth);
+    case "insert":
+      return parseInsert(classified.tokens, schema);
+    case "update":
+      return parseUpdate(classified.tokens, schema, maxJoinDepth);
+    case "delete":
+      return parseDelete(classified.tokens, schema, maxJoinDepth);
+    case "createTable":
+      return parseCreateTable(classified.tokens, schema);
+    case "dropTable":
+      return parseDropTable(classified.tokens, schema);
+  }
+}
+function parseDescribe(tokens, schema) {
+  const meaningful = tokens.filter(
+    (token) => !(token.type === "word" && (token.value === "is" || token.value === "in"))
+  );
+  const { table } = resolveTableFromTokens(meaningful, 0, schema);
+  return { kind: "describe", table: table.name };
+}
+function parseSelect(tokens, schema, maxJoinDepth, aggregate) {
+  const clauses = extractClauses(tokens);
+  const { columnTokens, tableTokens } = splitSubject(clauses.subject);
+  const { table, consumed } = resolveTableFromTokens(tableTokens, 0, schema);
+  const leftover = tableTokens[consumed];
+  const columns = columnTokens.length > 0 && !aggregate ? parseColumnList(columnTokens, table) : "*";
+  const parsed = parseConditions(clauses.conditionTokens, table, schema);
+  const foreignTables = new Set(parsed.foreignTables);
+  let where = parsed.where;
+  if (leftover && (leftover.type !== "word" || !isConnectorWord(leftover.value))) {
+    where = mergeWhere(nameLikeCondition(table, leftover), where);
+  }
+  const orderBy = parseSort(clauses, table, schema, foreignTables);
+  const joins = resolveJoins(table.name, [...foreignTables], schema, maxJoinDepth);
+  return {
+    kind: "select",
+    table: table.name,
+    columns,
+    aggregate,
+    joins,
+    where,
+    orderBy,
+    limit: clauses.limit,
+    offset: null
+  };
+}
+function isConnectorWord(value) {
+  return value === "and" || value === "or";
+}
+var descendingWords = /* @__PURE__ */ new Set(["descending", "desc", "reverse", "reversed", "highest"]);
+var ascendingWords = /* @__PURE__ */ new Set(["ascending", "asc", "lowest"]);
+function parseSort(clauses, table, schema, foreignTables) {
+  const orderBy = [];
+  let current = null;
+  for (const token of clauses.sortTokens) {
+    if (token.type === "comma" || token.type === "word" && token.value === "and") {
+      continue;
+    }
+    if (token.type === "word" && descendingWords.has(token.value)) {
+      if (current) {
+        current.direction = "desc";
+      }
+      continue;
+    }
+    if (token.type === "word" && ascendingWords.has(token.value)) {
+      continue;
+    }
+    if (token.type !== "word") {
+      throw new ParseError(`Expected a column to sort by, got "${token.raw}"`, {
+        position: token.position
+      });
+    }
+    const resolved = resolveColumn(token.value, table, schema);
+    if (resolved.requiresJoin) {
+      foreignTables.add(resolved.tableName);
+    }
+    current = {
+      column: { table: resolved.tableName, column: resolved.column.name },
+      direction: "asc"
+    };
+    orderBy.push(current);
+  }
+  if (orderBy.length === 0 && clauses.reverse) {
+    const pk = table.primaryKey[0];
+    if (pk) {
+      orderBy.push({ column: { table: table.name, column: pk }, direction: "desc" });
+    }
+  }
+  return orderBy;
+}
+function parseAggregate(tokens, fn, schema, maxJoinDepth) {
+  const clauses = extractClauses(tokens);
+  let { columnTokens, tableTokens } = splitSubject(clauses.subject);
+  if (columnTokens.length === 0) {
+    const inIndex = clauses.subject.findIndex(
+      (token) => token.type === "word" && token.value === "in"
+    );
+    if (inIndex > 0) {
+      columnTokens = clauses.subject.slice(0, inIndex);
+      tableTokens = clauses.subject.slice(inIndex + 1);
+    } else if (clauses.subject.length >= 2) {
+      columnTokens = clauses.subject.slice(0, -1);
+      tableTokens = clauses.subject.slice(-1);
+    }
+  }
+  const columnToken = columnTokens[0];
+  if (!columnToken || columnToken.type !== "word") {
+    throw new ParseError(`Expected "<${fn}> <column> of <table>"`, {
+      position: tokens[0]?.position
+    });
+  }
+  const { table } = resolveTableFromTokens(tableTokens, 0, schema);
+  const resolved = resolveColumn(columnToken.value, table, schema);
+  const foreignTables = /* @__PURE__ */ new Set();
+  if (resolved.requiresJoin) {
+    foreignTables.add(resolved.tableName);
+  }
+  const parsed = parseConditions(clauses.conditionTokens, table, schema);
+  for (const foreign of parsed.foreignTables) {
+    foreignTables.add(foreign);
+  }
+  return {
+    kind: "select",
+    table: table.name,
+    columns: "*",
+    aggregate: { fn, column: { table: resolved.tableName, column: resolved.column.name } },
+    joins: resolveJoins(table.name, [...foreignTables], schema, maxJoinDepth),
+    where: parsed.where,
+    orderBy: [],
+    limit: clauses.limit,
+    offset: null
+  };
+}
+
+// src/safety/guard.ts
+function classifyAst(ast) {
+  switch (ast.kind) {
+    case "select":
+    case "insert":
+    case "createTable":
+      return "safe";
+    case "update":
+    case "delete":
+      return ast.where ? "destructive" : "catastrophic";
+    case "dropTable":
+      return "catastrophic";
+  }
+}
+function astIsWrite(ast) {
+  return ast.kind !== "select";
+}
+var readOnlyStarters = /* @__PURE__ */ new Set([
+  "select",
+  "show",
+  "explain",
+  "describe",
+  "desc",
+  "table",
+  "values",
+  "begin",
+  "start",
+  "commit",
+  "rollback",
+  "end",
+  "set"
+]);
+var writeKeywords = /\b(insert|update|delete|drop|truncate|alter|create|grant|revoke|vacuum)\b/i;
+function rawSqlIsWrite(sql) {
+  const first = sql.trim().split(/\s+/)[0]?.toLowerCase() ?? "";
+  if (first === "with") {
+    return writeKeywords.test(sql.replace(/'[^']*'/g, ""));
+  }
+  return !readOnlyStarters.has(first);
+}
+function classifyRawSql(sql) {
+  const stripped = sql.replace(/'[^']*'/g, "").toLowerCase();
+  const first = stripped.trim().split(/\s+/)[0] ?? "";
+  if (first === "drop" || first === "truncate") {
+    return "catastrophic";
+  }
+  if (first === "delete" || first === "update") {
+    return /\bwhere\b/.test(stripped) ? "destructive" : "catastrophic";
+  }
+  return "safe";
+}
+function extractRawTargetTable(sql) {
+  const stripped = sql.trim();
+  const deleteMatch = /^delete\s+from\s+([\w".`]+)/i.exec(stripped);
+  if (deleteMatch?.[1]) {
+    return deleteMatch[1].replace(/["`]/g, "");
+  }
+  const updateMatch = /^update\s+([\w".`]+)/i.exec(stripped);
+  if (updateMatch?.[1]) {
+    return updateMatch[1].replace(/["`]/g, "");
+  }
+  const dropMatch = /^(?:drop|truncate)\s+table\s+(?:if\s+exists\s+)?([\w".`]+)/i.exec(stripped);
+  if (dropMatch?.[1]) {
+    return dropMatch[1].replace(/["`]/g, "");
+  }
+  const truncateMatch = /^truncate\s+([\w".`]+)/i.exec(stripped);
+  if (truncateMatch?.[1]) {
+    return truncateMatch[1].replace(/["`]/g, "");
+  }
+  return null;
+}
+
+// src/repl/history.ts
+import { appendFileSync, existsSync, readFileSync } from "fs";
+var MAX_LOADED_ENTRIES = 1e3;
+function loadHistory() {
+  const path = historyFilePath();
+  if (!existsSync(path)) {
+    return [];
+  }
+  const lines = readFileSync(path, "utf8").split("\n").filter(Boolean);
+  const entries = [];
+  for (const line of lines.slice(-MAX_LOADED_ENTRIES)) {
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return entries;
+}
+function appendHistory(entry) {
+  try {
+    appendFileSync(historyFilePath(), `${JSON.stringify(entry)}
+`, "utf8");
+  } catch {
+  }
+}
+function searchHistory(entries, term) {
+  const needle = term.toLowerCase();
+  return entries.filter((entry) => entry.input.toLowerCase().includes(needle));
+}
+
+// src/repl/controller.ts
+function block(kind, text) {
+  return { kind, text };
+}
+var sqlStarters = /* @__PURE__ */ new Set([
+  "select",
+  "insert",
+  "update",
+  "delete",
+  "create",
+  "alter",
+  "drop",
+  "truncate",
+  "with",
+  "begin",
+  "start",
+  "commit",
+  "rollback",
+  "end",
+  "explain",
+  "show",
+  "set",
+  "grant",
+  "revoke",
+  "vacuum",
+  "analyze",
+  "values",
+  "table",
+  "desc",
+  "describe"
+]);
+var sqlShapeMarkers = /(\bfrom\b|\binto\b|\bvalues\s*\(|\bjoin\b|\*|;|=|\breturning\b)/i;
+function startsWithSqlKeyword(input) {
+  const first = input.trim().split(/\s+/)[0]?.toLowerCase() ?? "";
+  return sqlStarters.has(first);
+}
+function hasSqlShape(input) {
+  return sqlShapeMarkers.test(input);
+}
+var ddlPattern = /^\s*(create|drop|alter|truncate)\b/i;
+var ReplController = class {
+  manager = new ConnectionManager();
+  config;
+  safety;
+  sqlLock = false;
+  lastResult = null;
+  lastSql = null;
+  lastParams = [];
+  inputHistory;
+  pending = null;
+  constructor() {
+    this.config = loadConfig();
+    this.safety = this.config.safety;
+    this.inputHistory = loadHistory().map((entry) => entry.input);
+  }
+  promptInfo() {
+    const connection = this.manager.active();
+    if (!connection) {
+      return null;
+    }
+    return {
+      alias: connection.alias,
+      database: connection.database,
+      dialect: connection.dialect,
+      env: connection.env,
+      readonly: connection.readonly,
+      inTransaction: connection.adapter.inTransaction(),
+      sqlLock: this.sqlLock
+    };
+  }
+  pendingConfirmation() {
+    return this.pending;
+  }
+  setPending(confirmation) {
+    this.pending = confirmation;
+  }
+  async handleInput(rawInput) {
+    const input = rawInput.trim();
+    if (!input) {
+      return { blocks: [] };
+    }
+    if (this.pending) {
+      return this.respondToPending(input);
+    }
+    try {
+      if (input.startsWith("\\")) {
+        const { dispatchMeta } = await import("./meta-NZ5Z6NYN.js");
+        return await dispatchMeta(this, input);
+      }
+      return await this.handleQuery(input);
+    } catch (error) {
+      return { blocks: [this.errorBlock(error)] };
+    }
+  }
+  errorBlock(error) {
+    if (error instanceof ParseError) {
+      const lines = [error.message];
+      if (error.suggestions.length > 0) {
+        lines.push(`Try: ${error.suggestions.join("  \xB7  ")}`);
+      }
+      return block("error", lines.join("\n"));
+    }
+    if (error instanceof AmbiguityError) {
+      const lines = [
+        error.message,
+        ...error.candidates.map((candidate) => `  - ${candidate.label} (${candidate.detail})`)
+      ];
+      return block("warn", lines.join("\n"));
+    }
+    if (error instanceof MidqlError) {
+      return block("error", error.message);
+    }
+    return block("error", error.message ?? String(error));
+  }
+  async respondToPending(input) {
+    const pending = this.pending;
+    this.pending = null;
+    const normalized = input.trim();
+    const confirmed = pending.expectedText ? normalized === pending.expectedText : /^y(es)?$/i.test(normalized);
+    if (!confirmed) {
+      return { blocks: [block("info", "Cancelled.")] };
+    }
+    try {
+      return { blocks: await pending.execute() };
+    } catch (error) {
+      return { blocks: [this.errorBlock(error)] };
+    }
+  }
+  safetyEnforced(connection) {
+    return this.safety === "on" || connection.env === "prod";
+  }
+  async handleQuery(input) {
+    const connection = this.manager.active();
+    if (!connection) {
+      return {
+        blocks: [
+          block("error", "Not connected. Use \\c <profile|url> to connect."),
+          block("info", "Example: \\c postgres://user:pass@localhost:5432/mydb")
+        ]
+      };
+    }
+    if (this.sqlLock) {
+      return this.runRawSql(connection, input);
+    }
+    if (startsWithSqlKeyword(input) && hasSqlShape(input)) {
+      return this.runRawSql(connection, input);
+    }
+    try {
+      const ast = translate(input, connection.schema, {
+        maxJoinDepth: this.config.maxJoinDepth
+      });
+      return await this.runAst(connection, input, ast);
+    } catch (error) {
+      if (error instanceof ParseError && startsWithSqlKeyword(input)) {
+        return this.runRawSql(connection, input);
+      }
+      throw error;
+    }
+  }
+  async runAst(connection, input, ast) {
+    const { executeAst } = await import("./execute-E45HSHNE.js");
+    return executeAst(this, connection, input, ast);
+  }
+  async runRawSql(connection, sql) {
+    if (connection.readonly && rawSqlIsWrite(sql)) {
+      return {
+        blocks: [
+          block("error", "Connection is read-only; write statements are blocked."),
+          block("info", "Use \\readonly off to allow writes on this connection.")
+        ]
+      };
+    }
+    const danger = classifyRawSql(sql);
+    if (danger !== "safe" && this.safetyEnforced(connection)) {
+      return this.confirmRawSql(connection, sql, danger);
+    }
+    return { blocks: await this.executeRaw(connection, sql) };
+  }
+  confirmRawSql(connection, sql, danger) {
+    const table = extractRawTargetTable(sql);
+    const verb = sql.trim().split(/\s+/)[0]?.toUpperCase() ?? "STATEMENT";
+    const prodBanner = connection.env === "prod" ? " (PRODUCTION)" : "";
+    const blocks = [];
+    if (danger === "catastrophic") {
+      const expected = table ?? "yes";
+      blocks.push(
+        block(
+          "error",
+          `\u26A0${prodBanner} ${verb} on ${table ?? "this database"}${/\bwhere\b/i.test(sql) ? "" : " affects every row"}.`
+        )
+      );
+      blocks.push(block("warn", `Type '${expected}' to confirm:`));
+      this.pending = {
+        prompt: `confirm ${expected}`,
+        expectedText: expected,
+        execute: () => this.executeRaw(connection, sql)
+      };
+    } else {
+      blocks.push(block("warn", `\u26A0${prodBanner} ${verb} will modify ${table ?? "data"}.`));
+      blocks.push(block("warn", "Proceed? [y/N]"));
+      this.pending = {
+        prompt: "y/N",
+        expectedText: null,
+        execute: () => this.executeRaw(connection, sql)
+      };
+    }
+    return { blocks };
+  }
+  async executeRaw(connection, sql) {
+    let result;
+    try {
+      result = await connection.adapter.sessionQuery(sql);
+    } catch (error) {
+      this.record(connection.alias, sql, sql, null, false);
+      throw error;
+    }
+    this.lastResult = result;
+    this.lastSql = sql;
+    this.lastParams = [];
+    this.record(connection.alias, sql, sql, result.rowCount, true);
+    if (ddlPattern.test(sql)) {
+      await this.manager.refreshSchema(connection.alias).catch(() => connection);
+    }
+    return [block("table", formatResultSet(result))];
+  }
+  record(connectionAlias, input, sql, rowCount, ok) {
+    this.inputHistory.push(input);
+    appendHistory({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      connection: connectionAlias,
+      input,
+      sql,
+      rowCount,
+      ok
+    });
+  }
+  async shutdown() {
+    const openTx = this.manager.list().filter((connection) => connection.adapter.inTransaction()).map((connection) => connection.alias);
+    await this.manager.closeAll();
+    if (openTx.length > 0) {
+      return [
+        block("warn", `Open transactions on ${openTx.join(", ")} were rolled back on disconnect.`)
+      ];
+    }
+    return [];
+  }
+};
+
+export {
+  extractClauses,
+  findTable,
+  buildFkGraph,
+  tokenize,
+  dropFillers,
+  translate,
+  classifyAst,
+  astIsWrite,
+  rawSqlIsWrite,
+  classifyRawSql,
+  loadHistory,
+  searchHistory,
+  block,
+  startsWithSqlKeyword,
+  hasSqlShape,
+  ReplController
+};