@deaquinodev/querky 0.4.0

package/dist/index.js

@@ -0,0 +1,2310 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { useState as useState5, useEffect as useEffect5 } from "react";
+import { parseArgs } from "util";
+import { render, Box as Box7, Text as Text7 } from "ink";
+
+// src/db/client.ts
+import { Client } from "pg";
+import { createConnection } from "mysql2/promise";
+import Database from "better-sqlite3";
+
+// src/config/keychain.ts
+var SERVICE = "querky";
+function accountKey(driver, user, host, port) {
+  return `${driver}:${user}@${host}:${port}`;
+}
+async function savePassword(driver, user, host, port, password) {
+  if (!password) return;
+  try {
+    const keytar = await import("keytar");
+    await keytar.default.setPassword(SERVICE, accountKey(driver, user, host, port), password);
+  } catch {
+  }
+}
+async function getPassword(driver, user, host, port) {
+  try {
+    const keytar = await import("keytar");
+    return await keytar.default.getPassword(SERVICE, accountKey(driver, user, host, port));
+  } catch {
+    return null;
+  }
+}
+
+// src/db/client.ts
+var PgDbClient = class {
+  constructor(pg) {
+    this.pg = pg;
+  }
+  pg;
+  async query(sql) {
+    const result = await this.pg.query(sql);
+    return {
+      fields: result.fields.map((f) => f.name),
+      rows: result.rows,
+      rowCount: result.rowCount ?? 0
+    };
+  }
+  async end() {
+    await this.pg.end();
+  }
+};
+var MysqlDbClient = class {
+  constructor(conn) {
+    this.conn = conn;
+  }
+  conn;
+  async query(sql) {
+    const [result, fields] = await this.conn.query(sql);
+    if (Array.isArray(result)) {
+      return {
+        fields: fields ? fields.map((f) => f.name ?? "") : [],
+        rows: result,
+        rowCount: result.length
+      };
+    }
+    const header = result;
+    return { fields: [], rows: [], rowCount: header.affectedRows ?? 0 };
+  }
+  async end() {
+    await this.conn.end();
+  }
+};
+var SqliteDbClient = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async query(sql) {
+    const stmt = this.db.prepare(sql);
+    if (stmt.reader) {
+      const rows = stmt.all();
+      const fields = stmt.columns().map((c) => c.name);
+      return { fields, rows, rowCount: rows.length };
+    }
+    const info = stmt.run();
+    return { fields: [], rows: [], rowCount: info.changes };
+  }
+  async end() {
+    this.db.close();
+  }
+};
+async function connectParams(params) {
+  try {
+    if (params.driver === "sqlite") {
+      const db = new Database(params.database);
+      return {
+        status: "connected",
+        client: new SqliteDbClient(db),
+        database: params.database,
+        host: "local",
+        user: "",
+        driver: "sqlite",
+        params
+      };
+    }
+    if (params.driver === "mysql") {
+      const conn = await createConnection({
+        host: params.host,
+        port: params.port,
+        database: params.database,
+        user: params.user,
+        password: params.password
+      });
+      const [rows] = await conn.query("SELECT DATABASE() AS db");
+      const database = rows[0]?.db ?? params.database;
+      void savePassword(params.driver, params.user, params.host, params.port, params.password);
+      return {
+        status: "connected",
+        client: new MysqlDbClient(conn),
+        database,
+        host: params.host,
+        user: params.user,
+        driver: "mysql",
+        params
+      };
+    }
+    const pg = new Client({
+      host: params.host,
+      port: params.port,
+      database: params.database,
+      user: params.user,
+      password: params.password
+    });
+    await pg.connect();
+    const res = await pg.query("SELECT current_database()");
+    void savePassword(params.driver, params.user, params.host, params.port, params.password);
+    return {
+      status: "connected",
+      client: new PgDbClient(pg),
+      database: res.rows[0].current_database,
+      host: pg.host,
+      user: pg.user ?? "unknown",
+      driver: "postgresql",
+      params
+    };
+  } catch (err) {
+    return { status: "error", message: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function connectDsn(dsn) {
+  try {
+    if (dsn.startsWith("sqlite:")) {
+      const filePath = dsn.replace(/^sqlite:\/\//, "").replace(/^\//, "") || dsn.replace("sqlite:", "");
+      return connectParams({ driver: "sqlite", host: "local", port: 0, database: filePath, user: "", password: "" });
+    }
+    const url = new URL(dsn);
+    const driver = url.protocol.startsWith("mysql") ? "mysql" : "postgresql";
+    if (driver === "postgresql") {
+      const pg = new Client({ connectionString: dsn });
+      await pg.connect();
+      const res = await pg.query("SELECT current_database()");
+      const params = {
+        driver: "postgresql",
+        host: pg.host,
+        port: pg.port ?? 5432,
+        database: res.rows[0].current_database,
+        user: pg.user ?? "",
+        password: decodeURIComponent(url.password)
+      };
+      return {
+        status: "connected",
+        client: new PgDbClient(pg),
+        database: res.rows[0].current_database,
+        host: pg.host,
+        user: pg.user ?? "unknown",
+        driver: "postgresql",
+        params
+      };
+    }
+    return connectParams({
+      driver: "mysql",
+      host: url.hostname || "localhost",
+      port: url.port ? parseInt(url.port) : 3306,
+      database: url.pathname.slice(1),
+      user: decodeURIComponent(url.username),
+      password: decodeURIComponent(url.password)
+    });
+  } catch (err) {
+    return { status: "error", message: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+// src/ui/components/App.tsx
+import { useState as useState3, useEffect as useEffect4, useRef as useRef2 } from "react";
+import { writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
+import { Box as Box5, Text as Text5, Static, useApp, useInput as useInput2, useStdin as useStdin2 } from "ink";
+
+// src/db/query.ts
+async function runQuery(client, sql) {
+  try {
+    const result = await client.query(sql);
+    return { status: "success", result };
+  } catch (err) {
+    return {
+      status: "error",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/config/aliases.ts
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".config", "querky");
+var ALIASES_FILE = join(CONFIG_DIR, "aliases.json");
+function load() {
+  try {
+    return JSON.parse(readFileSync(ALIASES_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function persist(store) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(ALIASES_FILE, JSON.stringify(store, null, 2));
+}
+function makeScope(driver, user, host, database) {
+  return `${driver}:${user}@${host}/${database}`;
+}
+function getAllAliases(scope) {
+  return load()[scope] ?? {};
+}
+function saveAlias(scope, name, query) {
+  const store = load();
+  store[scope] ??= {};
+  store[scope][name] = query;
+  persist(store);
+}
+function deleteAlias(scope, name) {
+  const store = load();
+  if (!store[scope]?.[name]) return false;
+  delete store[scope][name];
+  persist(store);
+  return true;
+}
+function expandAlias(template, rawArgs) {
+  if (/:([a-zA-Z_]\w*)/.test(template)) {
+    const named = {};
+    const re = /(\w+)=("(?:[^"\\]|\\.)*"|\S+)/g;
+    let m;
+    while ((m = re.exec(rawArgs)) !== null) {
+      named[m[1]] = m[2].replace(/^"|"$/g, "").replace(/\\"/g, '"');
+    }
+    return template.replace(/:([a-zA-Z_]\w*)/g, (_, k) => named[k] ?? `:${k}`);
+  }
+  const args = rawArgs ? rawArgs.match(/("(?:[^"\\]|\\.)*"|\S+)/g) ?? [] : [];
+  return template.replace(/\$(\d+)/g, (_, n) => {
+    const val = args[Number(n) - 1];
+    return val !== void 0 ? val.replace(/^"|"$/g, "") : `$${n}`;
+  });
+}
+
+// src/ui/completions.ts
+function fuzzyScore(token, candidate) {
+  if (token.length === 0) return 0;
+  let score = 0;
+  let ti = 0;
+  let run = 0;
+  for (let ci = 0; ci < candidate.length && ti < token.length; ci++) {
+    if (candidate[ci] === token[ti]) {
+      run++;
+      score += run * 2;
+      score += candidate.length - ci;
+      ti++;
+    } else {
+      run = 0;
+    }
+  }
+  if (ti < token.length) return -1;
+  if (candidate.startsWith(token)) score += 100;
+  return score;
+}
+function fuzzyMatchPositions(token, candidate) {
+  const positions = [];
+  let ti = 0;
+  for (let ci = 0; ci < candidate.length && ti < token.length; ci++) {
+    if (candidate[ci] === token[ti]) {
+      positions.push(ci);
+      ti++;
+    }
+  }
+  return ti === token.length ? positions : [];
+}
+var SQL_KEYWORDS = [
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "JOIN",
+  "LEFT",
+  "RIGHT",
+  "INNER",
+  "OUTER",
+  "CROSS",
+  "ON",
+  "AND",
+  "OR",
+  "NOT",
+  "IN",
+  "LIKE",
+  "ILIKE",
+  "BETWEEN",
+  "IS",
+  "NULL",
+  "INSERT",
+  "INTO",
+  "VALUES",
+  "UPDATE",
+  "SET",
+  "DELETE",
+  "CREATE",
+  "TABLE",
+  "DROP",
+  "ALTER",
+  "ADD",
+  "COLUMN",
+  "ORDER",
+  "BY",
+  "GROUP",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "DISTINCT",
+  "AS",
+  "CASE",
+  "WHEN",
+  "THEN",
+  "ELSE",
+  "END",
+  "UNION",
+  "ALL",
+  "EXISTS",
+  "WITH",
+  "RETURNING",
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MAX",
+  "MIN",
+  "COALESCE",
+  "NULLIF",
+  "CAST",
+  "PRIMARY",
+  "KEY",
+  "FOREIGN",
+  "REFERENCES",
+  "UNIQUE",
+  "DEFAULT",
+  "CONSTRAINT",
+  "BEGIN",
+  "COMMIT",
+  "ROLLBACK",
+  "EXPLAIN",
+  "ANALYZE"
+];
+var TABLE_CONTEXT = /* @__PURE__ */ new Set(["FROM", "JOIN", "INTO", "UPDATE", "TABLE"]);
+var COLUMN_CONTEXT = /* @__PURE__ */ new Set(["SELECT", "WHERE", "ON", "SET", "HAVING", "BY", "AND", "OR"]);
+function getCurrentToken(value, cursor) {
+  const before = value.slice(0, cursor);
+  const dotMatch = before.match(/\w+\.(\w*)$/);
+  if (dotMatch) return dotMatch[1];
+  const match = before.match(/(\w+)$/);
+  return match ? match[1] : "";
+}
+function getQualifiedTable(value, cursor) {
+  const before = value.slice(0, cursor);
+  const match = before.match(/(\w+)\.\w*$/);
+  return match ? match[1] : null;
+}
+function getContextKeyword(value, cursor) {
+  const before = value.slice(0, cursor).replace(/\w*$/, "");
+  const opens = (before.match(/\(/g) ?? []).length;
+  const closes = (before.match(/\)/g) ?? []).length;
+  if (opens > 0 && closes >= opens) return "";
+  const tokens = before.trim().split(/\s+/).filter(Boolean);
+  for (let i = tokens.length - 1; i >= 0; i--) {
+    const t = tokens[i].toUpperCase().replace(/[^A-Z]/g, "");
+    if (TABLE_CONTEXT.has(t) || COLUMN_CONTEXT.has(t)) return t;
+  }
+  return "";
+}
+function matchCase(keyword, token) {
+  const isLower = token === token.toLowerCase();
+  return isLower ? keyword.toLowerCase() : keyword.toUpperCase();
+}
+function getSqlCompletions(value, cursor, schema) {
+  const token = getCurrentToken(value, cursor);
+  const tokenLower = token.toLowerCase();
+  const ctx = getContextKeyword(value, cursor).toUpperCase();
+  function fuzzyRank(items) {
+    return items.map((item) => ({ item, score: fuzzyScore(tokenLower, item.toLowerCase()) })).filter(({ score }) => score >= 0).sort((a, b) => b.score - a.score).map(({ item }) => item);
+  }
+  const qualTable = getQualifiedTable(value, cursor);
+  if (qualTable) {
+    const cols = schema.columns[qualTable] ?? schema.columns[qualTable.toLowerCase()] ?? [];
+    return token.length === 0 ? cols.slice(0, 8) : fuzzyRank(cols).slice(0, 8);
+  }
+  if (TABLE_CONTEXT.has(ctx)) {
+    return token.length === 0 ? schema.tables.slice(0, 8) : fuzzyRank(schema.tables).slice(0, 8);
+  }
+  if (token.length < 1) return [];
+  if (COLUMN_CONTEXT.has(ctx)) {
+    const allCols2 = [...new Set(Object.values(schema.columns).flat())];
+    const matchingCols2 = fuzzyRank(allCols2);
+    const matchingTables2 = fuzzyRank(schema.tables);
+    const matchingKw2 = SQL_KEYWORDS.filter((k) => k.toLowerCase().startsWith(tokenLower)).map((k) => matchCase(k, token));
+    return [...matchingTables2, ...matchingCols2, ...matchingKw2].slice(0, 8);
+  }
+  const matchingKw = SQL_KEYWORDS.filter((k) => k.toLowerCase().startsWith(tokenLower)).map((k) => matchCase(k, token));
+  const matchingTables = fuzzyRank(schema.tables);
+  const allCols = [...new Set(Object.values(schema.columns).flat())];
+  const matchingCols = fuzzyRank(allCols);
+  return [...matchingKw, ...matchingTables, ...matchingCols].slice(0, 8);
+}
+function applyCompletion(value, cursor, completion) {
+  const before = value.slice(0, cursor);
+  const after = value.slice(cursor);
+  const dotMatch = before.match(/^([\s\S]*\w+\.)(\w*)$/);
+  if (dotMatch) {
+    const newBefore = dotMatch[1] + completion;
+    return { value: newBefore + after, cursor: newBefore.length };
+  }
+  const tokenMatch = before.match(/^([\s\S]*?)(\w+)$/);
+  if (tokenMatch) {
+    const newBefore = tokenMatch[1] + completion;
+    return { value: newBefore + after, cursor: newBefore.length };
+  }
+  return { value: before + completion + after, cursor: cursor + completion.length };
+}
+
+// src/commands/router.ts
+var DB_QUERIES = {
+  postgresql: {
+    databases: `SELECT datname AS database FROM pg_database WHERE datistemplate = false ORDER BY datname`,
+    tables: `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' ORDER BY table_name`,
+    users: `SELECT usename AS user, usesuper AS superuser FROM pg_user ORDER BY usename`
+  },
+  mysql: {
+    databases: `SHOW DATABASES`,
+    tables: `SHOW TABLES`,
+    users: `SELECT user, host FROM mysql.user ORDER BY user`
+  },
+  sqlite: {
+    databases: `SELECT name FROM pragma_database_list`,
+    tables: `SELECT name FROM sqlite_master WHERE type='table' ORDER BY name`,
+    users: `SELECT 'SQLite has no users' AS message`
+  }
+};
+var PSQL_ALIASES = {
+  l: "databases",
+  d: "d",
+  dt: "tables",
+  du: "users",
+  c: "changeDatabase"
+};
+function describeBasicSql(driver, table) {
+  const t = table.replace(/'/g, "''");
+  if (driver === "postgresql") {
+    return `SELECT column_name, data_type, is_nullable AS nullable, COALESCE(column_default, '') AS "default" FROM information_schema.columns WHERE table_schema = 'public' AND table_name = '${t}' ORDER BY ordinal_position`;
+  }
+  if (driver === "mysql") {
+    return `SELECT column_name, column_type AS data_type, is_nullable AS nullable, COALESCE(column_default, '') AS \`default\` FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = '${t}' ORDER BY ordinal_position`;
+  }
+  return `SELECT name AS column_name, type AS data_type, CASE WHEN "notnull" = 0 THEN 'YES' ELSE 'NO' END AS nullable, COALESCE(dflt_value, '') AS "default" FROM pragma_table_info('${t}')`;
+}
+function describeFullSql(driver, table) {
+  const t = table.replace(/'/g, "''");
+  if (driver === "postgresql") {
+    return `SELECT c.column_name, c.data_type, c.is_nullable AS nullable, COALESCE(c.column_default, '') AS "default", COALESCE(string_agg(DISTINCT CASE tc.constraint_type WHEN 'PRIMARY KEY' THEN 'PK' WHEN 'FOREIGN KEY' THEN 'FK' WHEN 'UNIQUE' THEN 'UQ' END, ', ') FILTER (WHERE tc.constraint_type IS NOT NULL), '') AS key FROM information_schema.columns c LEFT JOIN information_schema.key_column_usage kcu ON kcu.table_schema = c.table_schema AND kcu.table_name = c.table_name AND kcu.column_name = c.column_name LEFT JOIN information_schema.table_constraints tc ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema WHERE c.table_schema = 'public' AND c.table_name = '${t}' GROUP BY c.column_name, c.data_type, c.is_nullable, c.column_default, c.ordinal_position ORDER BY c.ordinal_position`;
+  }
+  if (driver === "mysql") {
+    return `SELECT c.column_name, c.column_type AS data_type, c.is_nullable AS nullable, COALESCE(c.column_default, '') AS \`default\`, COALESCE(GROUP_CONCAT(DISTINCT CASE tc.constraint_type WHEN 'PRIMARY KEY' THEN 'PK' WHEN 'FOREIGN KEY' THEN 'FK' WHEN 'UNIQUE' THEN 'UQ' END SEPARATOR ', '), '') AS \`key\` FROM information_schema.columns c LEFT JOIN information_schema.key_column_usage kcu ON kcu.table_schema = c.table_schema AND kcu.table_name = c.table_name AND kcu.column_name = c.column_name LEFT JOIN information_schema.table_constraints tc ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema WHERE c.table_schema = DATABASE() AND c.table_name = '${t}' GROUP BY c.column_name, c.column_type, c.is_nullable, c.column_default, c.ordinal_position ORDER BY c.ordinal_position`;
+  }
+  return `SELECT name AS column_name, type AS data_type, CASE WHEN "notnull" = 0 THEN 'YES' ELSE 'NO' END AS nullable, COALESCE(dflt_value, '') AS "default", CASE WHEN pk > 0 THEN 'PK' ELSE '' END AS key FROM pragma_table_info('${t}')`;
+}
+var COMMANDS = {
+  "clear": {
+    description: "Clear the scrollback history",
+    run: (ctx) => {
+      ctx.onClear();
+      return { ok: true, message: "", cleared: true };
+    }
+  },
+  "toggle-vim-mode": {
+    description: "Toggle vim keybindings on/off",
+    run: (ctx) => {
+      const next = !ctx.vimEnabled;
+      ctx.setVimEnabled(next);
+      return { ok: true, message: `Vim mode ${next ? "enabled" : "disabled"}` };
+    }
+  },
+  "d": {
+    description: "List tables, or describe a table: \\d [table]",
+    run: (ctx) => {
+      if (!ctx.args.trim()) {
+        ctx.onQuery(DB_QUERIES[ctx.driver].tables);
+      } else {
+        ctx.onQuery(describeBasicSql(ctx.driver, ctx.args.trim()));
+      }
+      return { ok: true, message: "" };
+    }
+  },
+  "describe": {
+    description: "Describe a table with constraints: /describe <table>",
+    run: (ctx) => {
+      const table = ctx.args.trim();
+      if (!table) return { ok: false, message: "Usage: /describe <table>" };
+      ctx.onQuery(describeFullSql(ctx.driver, table));
+      return { ok: true, message: "" };
+    }
+  },
+  "databases": {
+    description: "List available databases",
+    run: (ctx) => {
+      ctx.onQuery(DB_QUERIES[ctx.driver].databases);
+      return { ok: true, message: "" };
+    }
+  },
+  "tables": {
+    description: "List tables in the current database",
+    run: (ctx) => {
+      ctx.onQuery(DB_QUERIES[ctx.driver].tables);
+      return { ok: true, message: "" };
+    }
+  },
+  "users": {
+    description: "List database users",
+    run: (ctx) => {
+      ctx.onQuery(DB_QUERIES[ctx.driver].users);
+      return { ok: true, message: "" };
+    }
+  },
+  "changeDatabase": {
+    description: "Switch to a different database: \\c dbname",
+    run: (ctx) => {
+      if (!ctx.args) return { ok: true, message: `Connected to database: ${ctx.currentDatabase}` };
+      ctx.onChangeDatabase(ctx.args.trim());
+      return { ok: true, message: "" };
+    }
+  },
+  "export": {
+    description: "Export last result to a file: /export csv or /export json",
+    run: (ctx) => {
+      const fmt = ctx.args.trim().toLowerCase();
+      if (fmt !== "csv" && fmt !== "json") {
+        return { ok: false, message: "Usage: /export csv  or  /export json" };
+      }
+      ctx.onExport(fmt);
+      return { ok: true, message: "" };
+    }
+  },
+  "explain": {
+    description: "Explain a SQL query using AI: /explain SELECT ...",
+    run: (ctx) => {
+      if (!ctx.args) return { ok: false, message: "Usage: /explain <SQL query>" };
+      ctx.onExplain(ctx.args);
+      return { ok: true, message: "" };
+    }
+  },
+  "explain-previous": {
+    description: "Explain the last executed query using AI",
+    run: (ctx) => {
+      if (!ctx.lastSqlQuery) {
+        return { ok: false, message: "No query to explain \u2014 run a SQL query first." };
+      }
+      ctx.onExplain(ctx.lastSqlQuery);
+      return { ok: true, message: "" };
+    }
+  },
+  "save": {
+    description: "Save last query as an alias: /save <name>",
+    run: (ctx) => {
+      const name = ctx.args.trim();
+      if (!name) return { ok: false, message: "Usage: /save <name>" };
+      if (!ctx.lastSqlQuery) return { ok: false, message: "No query to save \u2014 run a SQL query first." };
+      if (/\s/.test(name)) return { ok: false, message: "Alias name must not contain spaces." };
+      ctx.onSaveAlias(name, ctx.lastSqlQuery);
+      return { ok: true, message: `Saved /${name}` };
+    }
+  },
+  "alias": {
+    description: "Define an alias inline: /alias <name> <SQL>",
+    run: (ctx) => {
+      const [name, ...rest] = ctx.args.trim().split(/\s+/);
+      if (!name || rest.length === 0) return { ok: false, message: "Usage: /alias <name> <SQL>" };
+      if (/\s/.test(name)) return { ok: false, message: "Alias name must not contain spaces." };
+      ctx.onSaveAlias(name, rest.join(" "));
+      return { ok: true, message: `Saved /${name}` };
+    }
+  },
+  "aliases": {
+    description: "List all saved aliases for this database",
+    run: (ctx) => {
+      const entries = Object.entries(ctx.aliases);
+      if (entries.length === 0) return { ok: true, message: "No aliases saved. Use /save <name> or /alias <name> <SQL>." };
+      const maxLen = Math.max(...entries.map(([n]) => n.length));
+      const lines = entries.map(
+        ([n, sql], i) => `${i === 0 ? "\xB7" : "  \xB7"} /${n.padEnd(maxLen)}  \u2192  ${sql}`
+      );
+      return { ok: true, message: lines.join("\n") };
+    }
+  },
+  "unalias": {
+    description: "Remove a saved alias: /unalias <name>",
+    run: (ctx) => {
+      const name = ctx.args.trim();
+      if (!name) return { ok: false, message: "Usage: /unalias <name>" };
+      const removed = ctx.onDeleteAlias(name);
+      return removed ? { ok: true, message: `Removed /${name}` } : { ok: false, message: `No alias named /${name}` };
+    }
+  }
+};
+var BUILTIN_COMMAND_LIST = Object.entries(COMMANDS).map(([name, cmd]) => ({
+  name,
+  description: cmd.description
+}));
+function getCompletions(partial, aliases = {}) {
+  if (partial.length === 0) return BUILTIN_COMMAND_LIST.map((c) => c.name);
+  const tokenLower = partial.toLowerCase();
+  const candidates = [
+    ...BUILTIN_COMMAND_LIST.map((c) => c.name),
+    ...Object.keys(aliases).filter((n) => !COMMANDS[n])
+  ];
+  return candidates.map((n) => ({ n, score: fuzzyScore(tokenLower, n.toLowerCase()) })).filter(({ score }) => score >= 0).sort((a, b) => b.score - a.score).map(({ n }) => n);
+}
+function runCommand(input, ctx) {
+  const trimmed = input.slice(1).trim();
+  const spaceIdx = trimmed.indexOf(" ");
+  const rawName = spaceIdx === -1 ? trimmed : trimmed.slice(0, spaceIdx);
+  const args = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1);
+  const name = PSQL_ALIASES[rawName ?? ""] ?? rawName ?? "";
+  const cmd = COMMANDS[name];
+  const prefix = input.startsWith("\\") ? "\\" : "/";
+  if (cmd) return cmd.run({ ...ctx, args });
+  const template = ctx.aliases[rawName];
+  if (template) {
+    const expanded = expandAlias(template, args);
+    ctx.onQuery(expanded);
+    return { ok: true, message: "" };
+  }
+  return { ok: false, message: `Unknown command: ${prefix}${rawName}` };
+}
+
+// src/commands/shell.ts
+import { exec } from "child_process";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync } from "fs";
+import { homedir as homedir2, tmpdir } from "os";
+import { join as join2 } from "path";
+var ANSI_CONTROL_RE = /\x1B\[(?:[0-9;]*[GKHJFST]|[?][0-9;]*[hl])/g;
+var stripControl = (s) => s.replace(ANSI_CONTROL_RE, "").replace(/\r/g, "");
+var MAX_LINES = 200;
+function trimLines(s) {
+  const lines = s.split("\n");
+  if (lines.length <= MAX_LINES) return s;
+  return lines.slice(0, MAX_LINES).join("\n") + `
+\u2026 (truncated, ${lines.length - MAX_LINES} more lines)`;
+}
+function readHistory(countArg) {
+  const shell = process.env.SHELL ?? "/bin/sh";
+  const histFile = process.env.HISTFILE ?? (shell.endsWith("zsh") ? join2(homedir2(), ".zsh_history") : join2(homedir2(), ".bash_history"));
+  let raw;
+  try {
+    raw = readFileSync2(histFile, "utf8");
+  } catch {
+    return { stdout: "", stderr: `history: cannot read ${histFile}`, exitCode: 1 };
+  }
+  const commands = raw.split("\n").map((line) => line.replace(/^: \d+:\d+;/, "")).filter(Boolean);
+  const count = countArg ? parseInt(countArg, 10) : NaN;
+  const visible = Number.isFinite(count) && count > 0 ? commands.slice(-count) : commands;
+  const offset = commands.length - visible.length + 1;
+  const output = visible.map((cmd, i) => `${String(offset + i).padStart(5)}  ${cmd}`).join("\n");
+  return { stdout: output || "(no history)", stderr: "", exitCode: 0 };
+}
+function runShell(command) {
+  const trimmed = command.trim();
+  const historyMatch = trimmed.match(/^history(?:\s+(\d+))?(\s.*)?$/);
+  if (historyMatch) {
+    const countStr = historyMatch[1] ?? "";
+    const rest = (historyMatch[2] ?? "").trimStart();
+    const histResult = readHistory(countStr);
+    if (histResult.exitCode !== 0 || !rest) return Promise.resolve(histResult);
+    const tmpPath = join2(tmpdir(), `querky-hist-${Date.now()}.txt`);
+    writeFileSync2(tmpPath, histResult.stdout);
+    const piped = `cat '${tmpPath}' ${rest}`;
+    const shell2 = process.env.SHELL ?? "/bin/sh";
+    const env2 = { ...process.env, CLICOLOR_FORCE: "1", COLORTERM: "truecolor", FORCE_COLOR: "3" };
+    return new Promise((resolve) => {
+      exec(piped, { shell: shell2, timeout: 3e4, env: env2 }, (err, stdout, stderr) => {
+        try {
+          unlinkSync(tmpPath);
+        } catch {
+        }
+        resolve({
+          stdout: trimLines(stripControl(stdout).trimEnd()),
+          stderr: trimLines(stripControl(stderr).trimEnd()),
+          exitCode: err?.code ?? 0
+        });
+      });
+    });
+  }
+  const shell = process.env.SHELL ?? "/bin/sh";
+  const env = {
+    ...process.env,
+    CLICOLOR_FORCE: "1",
+    // BSD + newer GNU coreutils: force color even without TTY
+    COLORTERM: "truecolor",
+    // hint: terminal supports 24-bit color
+    FORCE_COLOR: "3"
+    // Node.js / chalk-based CLIs
+  };
+  return new Promise((resolve) => {
+    exec(command, { shell, timeout: 3e4, env }, (err, stdout, stderr) => {
+      resolve({
+        stdout: trimLines(stripControl(stdout).trimEnd()),
+        stderr: trimLines(stripControl(stderr).trimEnd()),
+        exitCode: err?.code ?? 0
+      });
+    });
+  });
+}
+
+// src/ai/client.ts
+var EXPLAIN_PROMPT = (query) => `You are a SQL expert. Explain this query in plain English. Be concise \u2014 2-4 sentences max. Do not repeat the SQL back.
+
+SQL: ${query}`;
+async function* streamExplain(query, baseUrl, model, apiKey) {
+  let res;
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+  try {
+    res = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        model,
+        stream: true,
+        messages: [{ role: "user", content: EXPLAIN_PROMPT(query) }]
+      })
+    });
+  } catch {
+    throw new Error("Could not reach Ollama \u2014 is it running? Try: ollama serve");
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Ollama error ${res.status}: ${body || res.statusText}`);
+  }
+  const reader = res.body?.getReader();
+  if (!reader) throw new Error("No response body from Ollama");
+  const decoder = new TextDecoder();
+  let buf = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    const lines = buf.split("\n");
+    buf = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("data:")) continue;
+      const data = trimmed.slice(5).trim();
+      if (data === "[DONE]") return;
+      try {
+        const chunk = JSON.parse(data);
+        const content = chunk.choices[0]?.delta?.content;
+        if (content) yield content;
+      } catch {
+      }
+    }
+  }
+}
+
+// src/config/history.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+var DIR = join3(homedir3(), ".config", "querky");
+var FILE = join3(DIR, "history.json");
+var MAX = 1e3;
+function loadHistory() {
+  try {
+    return JSON.parse(readFileSync3(FILE, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function saveHistory(entries) {
+  try {
+    mkdirSync2(DIR, { recursive: true });
+    writeFileSync3(FILE, JSON.stringify(entries));
+  } catch {
+  }
+}
+function addToHistory(history, query) {
+  const deduped = history.filter((e) => e !== query);
+  return [...deduped, query].slice(-MAX);
+}
+
+// src/db/schema.ts
+var TABLE_QUERY = {
+  postgresql: `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' ORDER BY table_name`,
+  mysql: `SELECT table_name FROM information_schema.tables WHERE table_schema = DATABASE() ORDER BY table_name`,
+  sqlite: `SELECT name FROM sqlite_master WHERE type='table' ORDER BY name`
+};
+var COLUMN_QUERY = {
+  postgresql: `SELECT table_name, column_name FROM information_schema.columns WHERE table_schema = 'public' ORDER BY table_name, ordinal_position`,
+  mysql: `SELECT table_name, column_name FROM information_schema.columns WHERE table_schema = DATABASE() ORDER BY table_name, ordinal_position`,
+  sqlite: null
+};
+async function fetchSchema(client, driver) {
+  try {
+    const tableResult = await client.query(TABLE_QUERY[driver]);
+    const tables = tableResult.rows.map((r) => String(Object.values(r)[0] ?? "")).filter(Boolean);
+    const columns = {};
+    if (driver === "sqlite") {
+      for (const table of tables) {
+        try {
+          const info = await client.query(`PRAGMA table_info("${table}")`);
+          columns[table] = info.rows.map((r) => String(r["name"] ?? "")).filter(Boolean);
+        } catch {
+        }
+      }
+    } else {
+      const colQuery = COLUMN_QUERY[driver];
+      if (colQuery) {
+        const colResult = await client.query(colQuery);
+        for (const row of colResult.rows) {
+          const table = String(row["table_name"] ?? "");
+          const col = String(row["column_name"] ?? "");
+          if (table && col) {
+            columns[table] ??= [];
+            columns[table].push(col);
+          }
+        }
+      }
+    }
+    return { tables, columns };
+  } catch {
+    return { tables: [], columns: {} };
+  }
+}
+
+// src/ui/components/QueryInput.tsx
+import { useEffect as useEffect2 } from "react";
+import { Box, Text } from "ink";
+
+// src/ui/hooks/useVimInput.ts
+import { useState, useEffect, useRef } from "react";
+import { spawnSync } from "child_process";
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join4 } from "path";
+import { useInput, useStdin } from "ink";
+function wordForward(str, pos) {
+  let i = pos;
+  while (i < str.length && !/\s/.test(str[i])) i++;
+  while (i < str.length && /\s/.test(str[i])) i++;
+  return i;
+}
+function wordBackward(str, pos) {
+  let i = pos;
+  while (i > 0 && /\s/.test(str[i - 1])) i--;
+  while (i > 0 && !/\s/.test(str[i - 1])) i--;
+  return i;
+}
+function deleteWordForward(str, pos) {
+  const end = wordForward(str, pos);
+  return str.slice(0, pos) + str.slice(end);
+}
+function deleteWordBackward(str, pos) {
+  const start = wordBackward(str, pos);
+  return { value: str.slice(0, start) + str.slice(pos), cursor: start };
+}
+function useVimInput(onSubmit, isActive, vimEnabled = true, onTab, history = [], getSuggestions, onSuggestionAccept) {
+  const { isRawModeSupported } = useStdin();
+  const [state, setState] = useState({
+    value: "",
+    cursor: 0,
+    mode: "INSERT",
+    pending: "",
+    yank: "",
+    historyIndex: -1,
+    draft: "",
+    suggestionIndex: -1,
+    pendingSubmit: null,
+    pendingEditor: null
+  });
+  const onSubmitRef = useRef(onSubmit);
+  onSubmitRef.current = onSubmit;
+  useEffect(() => {
+    if (state.pendingSubmit !== null) {
+      onSubmitRef.current(state.pendingSubmit);
+      setState((s) => ({ ...s, pendingSubmit: null }));
+    }
+  }, [state.pendingSubmit]);
+  useEffect(() => {
+    if (state.pendingEditor === null) return;
+    const initialContent = state.pendingEditor;
+    const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
+    const tmpPath = join4(tmpdir2(), `querky-edit-${Date.now()}.sql`);
+    const ttyStdin = process.stdin;
+    try {
+      writeFileSync4(tmpPath, initialContent);
+      process.stdout.write("\x1B[?25h");
+      ttyStdin.setRawMode?.(false);
+      spawnSync(editor, [tmpPath], { stdio: "inherit" });
+      process.stdout.write("\x1B[2J\x1B[H\x1B[?25l");
+      ttyStdin.setRawMode?.(true);
+      const content = readFileSync4(tmpPath, "utf8").trimEnd();
+      setState((s) => ({ ...s, pendingEditor: null, value: content, cursor: content.length, mode: "INSERT" }));
+    } catch {
+      ttyStdin.setRawMode?.(true);
+      setState((s) => ({ ...s, pendingEditor: null }));
+    } finally {
+      try {
+        unlinkSync2(tmpPath);
+      } catch {
+      }
+    }
+  }, [state.pendingEditor]);
+  useInput(
+    (input, key) => {
+      setState((s) => {
+        if (s.mode === "INSERT") {
+          if (key.escape) {
+            if (s.value.startsWith("!")) {
+              return { ...s, value: "", cursor: 0, pending: "" };
+            }
+            if (!vimEnabled) return s;
+            return { ...s, mode: "NORMAL", cursor: Math.max(0, s.cursor - 1), pending: "" };
+          }
+          if (key.return) {
+            const sugs = getSuggestions?.(s.value, s.cursor) ?? [];
+            if (sugs.length > 0 && s.suggestionIndex >= 0) {
+              const sug = sugs[s.suggestionIndex];
+              if (onSuggestionAccept) {
+                const r = onSuggestionAccept(s.value, s.cursor, sug);
+                return { ...s, value: r.value, cursor: r.cursor, suggestionIndex: -1 };
+              }
+              const val = `/${sug}`;
+              return { ...s, value: val, cursor: val.length, suggestionIndex: -1 };
+            }
+            const trimmed = s.value.trim();
+            return { value: "", cursor: 0, mode: "INSERT", pending: "", yank: s.yank, historyIndex: -1, draft: "", suggestionIndex: -1, pendingSubmit: trimmed || null };
+          }
+          if (key.upArrow) {
+            const sugs = getSuggestions?.(s.value, s.cursor) ?? [];
+            if (sugs.length > 0) {
+              const next2 = s.suggestionIndex <= 0 ? sugs.length - 1 : s.suggestionIndex - 1;
+              return { ...s, suggestionIndex: next2 };
+            }
+            if (history.length === 0) return s;
+            const draft = s.historyIndex === -1 ? s.value : s.draft;
+            const next = s.historyIndex === -1 ? history.length - 1 : Math.max(0, s.historyIndex - 1);
+            const val = history[next] ?? "";
+            return { ...s, value: val, cursor: val.length, historyIndex: next, draft };
+          }
+          if (key.downArrow) {
+            const sugs = getSuggestions?.(s.value, s.cursor) ?? [];
+            if (sugs.length > 0) {
+              const next2 = s.suggestionIndex >= sugs.length - 1 ? 0 : s.suggestionIndex + 1;
+              return { ...s, suggestionIndex: next2 };
+            }
+            if (s.historyIndex === -1) return s;
+            if (s.historyIndex === history.length - 1) {
+              return { ...s, value: s.draft, cursor: s.draft.length, historyIndex: -1, draft: "" };
+            }
+            const next = s.historyIndex + 1;
+            const val = history[next] ?? "";
+            return { ...s, value: val, cursor: val.length, historyIndex: next };
+          }
+          if (key.backspace || key.delete) {
+            if (s.cursor === 0) return s;
+            return {
+              ...s,
+              value: s.value.slice(0, s.cursor - 1) + s.value.slice(s.cursor),
+              cursor: s.cursor - 1,
+              historyIndex: -1
+            };
+          }
+          if (key.leftArrow) return { ...s, cursor: Math.max(0, s.cursor - 1) };
+          if (key.rightArrow) return { ...s, cursor: Math.min(s.value.length, s.cursor + 1) };
+          if (key.tab) {
+            const sugs = getSuggestions?.(s.value, s.cursor) ?? [];
+            if (sugs.length > 0) {
+              const next = s.suggestionIndex < sugs.length - 1 ? s.suggestionIndex + 1 : 0;
+              return { ...s, suggestionIndex: next };
+            }
+            const completed = onTab?.(s.value);
+            if (completed != null) return { ...s, value: completed, cursor: completed.length };
+            return s;
+          }
+          if (key.ctrl && input === "e") {
+            return { ...s, pendingEditor: s.value };
+          }
+          if (!key.ctrl && !key.meta && input) {
+            const chars = input === "!" && s.value === "" ? "! " : input;
+            return {
+              ...s,
+              value: s.value.slice(0, s.cursor) + chars + s.value.slice(s.cursor),
+              cursor: s.cursor + chars.length,
+              historyIndex: -1,
+              suggestionIndex: -1
+            };
+          }
+          return s;
+        }
+        if (key.return) {
+          const trimmed = s.value.trim();
+          return { value: "", cursor: 0, mode: "INSERT", pending: "", yank: s.yank, historyIndex: -1, draft: "", suggestionIndex: -1, pendingSubmit: trimmed || null };
+        }
+        if (s.pending === "d") {
+          if (input === "d") {
+            return { ...s, value: "", cursor: 0, pending: "" };
+          }
+          if (input === "w") {
+            const val = deleteWordForward(s.value, s.cursor);
+            return { ...s, value: val, cursor: Math.min(s.cursor, Math.max(0, val.length - 1)), pending: "" };
+          }
+          if (input === "b") {
+            const { value, cursor } = deleteWordBackward(s.value, s.cursor);
+            return { ...s, value, cursor: Math.min(cursor, Math.max(0, value.length - 1)), pending: "" };
+          }
+          return { ...s, pending: "" };
+        }
+        if (s.pending === "c") {
+          if (input === "c") {
+            return { ...s, value: "", cursor: 0, mode: "INSERT", pending: "" };
+          }
+          if (input === "w") {
+            const val = deleteWordForward(s.value, s.cursor);
+            return { ...s, value: val, cursor: s.cursor, mode: "INSERT", pending: "" };
+          }
+          if (input === "b") {
+            const { value, cursor } = deleteWordBackward(s.value, s.cursor);
+            return { ...s, value, cursor, mode: "INSERT", pending: "" };
+          }
+          return { ...s, pending: "" };
+        }
+        if (s.pending === "y") {
+          if (input === "y") {
+            return { ...s, yank: s.value, pending: "" };
+          }
+          return { ...s, pending: "" };
+        }
+        const maxCursor = Math.max(0, s.value.length - 1);
+        switch (input) {
+          case "i":
+            return { ...s, mode: "INSERT", pending: "" };
+          case "a":
+            return { ...s, mode: "INSERT", cursor: Math.min(s.value.length, s.cursor + 1), pending: "" };
+          case "A":
+            return { ...s, mode: "INSERT", cursor: s.value.length, pending: "" };
+          case "I":
+            return { ...s, mode: "INSERT", cursor: 0, pending: "" };
+          case "h":
+            return { ...s, cursor: Math.max(0, s.cursor - 1) };
+          case "l":
+            return { ...s, cursor: Math.min(maxCursor, s.cursor + 1) };
+          case "w":
+            return { ...s, cursor: Math.min(maxCursor, wordForward(s.value, s.cursor)) };
+          case "b":
+            return { ...s, cursor: wordBackward(s.value, s.cursor) };
+          case "e":
+            return { ...s, pendingEditor: s.value };
+          case "0":
+            return { ...s, cursor: 0 };
+          case "$":
+            return { ...s, cursor: maxCursor };
+          case "x": {
+            if (s.cursor >= s.value.length) return s;
+            const val = s.value.slice(0, s.cursor) + s.value.slice(s.cursor + 1);
+            return { ...s, value: val, cursor: Math.min(s.cursor, Math.max(0, val.length - 1)) };
+          }
+          case "s": {
+            if (s.cursor >= s.value.length) return { ...s, mode: "INSERT" };
+            const val = s.value.slice(0, s.cursor) + s.value.slice(s.cursor + 1);
+            return { ...s, value: val, cursor: s.cursor, mode: "INSERT" };
+          }
+          case "S": {
+            return { ...s, value: "", cursor: 0, mode: "INSERT" };
+          }
+          case "C": {
+            const val = s.value.slice(0, s.cursor);
+            return { ...s, value: val, cursor: Math.min(s.cursor, Math.max(0, val.length - 1)), mode: "INSERT" };
+          }
+          case "D": {
+            const val = s.value.slice(0, s.cursor);
+            return { ...s, value: val, cursor: Math.min(s.cursor, Math.max(0, val.length - 1)) };
+          }
+          case "p": {
+            if (!s.yank) return s;
+            const insertAt = Math.min(s.cursor + 1, s.value.length);
+            const val = s.value.slice(0, insertAt) + s.yank + s.value.slice(insertAt);
+            return { ...s, value: val, cursor: Math.max(0, insertAt + s.yank.length - 1) };
+          }
+          case "d":
+            return { ...s, pending: "d" };
+          case "c":
+            return { ...s, pending: "c" };
+          case "y":
+            return { ...s, pending: "y" };
+          default:
+            return s;
+        }
+      });
+    },
+    { isActive: isActive && (isRawModeSupported ?? false) }
+  );
+  return { value: state.value, cursor: state.cursor, mode: vimEnabled ? state.mode : "INSERT", suggestionIndex: state.suggestionIndex };
+}
+
+// src/ui/sqlHighlight.ts
+var SQL_KW = /* @__PURE__ */ new Set([
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "AND",
+  "OR",
+  "NOT",
+  "IN",
+  "IS",
+  "NULL",
+  "LIKE",
+  "BETWEEN",
+  "EXISTS",
+  "CASE",
+  "WHEN",
+  "THEN",
+  "ELSE",
+  "END",
+  "JOIN",
+  "INNER",
+  "LEFT",
+  "RIGHT",
+  "FULL",
+  "OUTER",
+  "CROSS",
+  "ON",
+  "AS",
+  "DISTINCT",
+  "ORDER",
+  "BY",
+  "GROUP",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "INSERT",
+  "INTO",
+  "VALUES",
+  "UPDATE",
+  "SET",
+  "DELETE",
+  "CREATE",
+  "TABLE",
+  "DROP",
+  "ALTER",
+  "ADD",
+  "COLUMN",
+  "PRIMARY",
+  "KEY",
+  "FOREIGN",
+  "REFERENCES",
+  "INDEX",
+  "UNIQUE",
+  "DEFAULT",
+  "CONSTRAINT",
+  "WITH",
+  "UNION",
+  "ALL",
+  "EXCEPT",
+  "INTERSECT",
+  "RETURNING",
+  "TRUE",
+  "FALSE",
+  "ASC",
+  "DESC",
+  "NULLS",
+  "FIRST",
+  "LAST",
+  "ILIKE",
+  "SIMILAR",
+  "TO",
+  "CAST",
+  "COALESCE",
+  "NULLIF",
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MIN",
+  "MAX",
+  "GREATEST",
+  "LEAST",
+  "OVER",
+  "PARTITION",
+  "WINDOW",
+  "FILTER",
+  "LATERAL",
+  "USING",
+  "NATURAL",
+  "EXPLAIN",
+  "ANALYZE",
+  "VERBOSE"
+]);
+function tokenizeSql(sql) {
+  const tokens = [];
+  let i = 0;
+  while (i < sql.length) {
+    if (sql[i] === "-" && sql[i + 1] === "-") {
+      const nl = sql.indexOf("\n", i);
+      const end = nl === -1 ? sql.length : nl;
+      tokens.push({ type: "comment", text: sql.slice(i, end) });
+      i = end;
+      continue;
+    }
+    if (sql[i] === "/" && sql[i + 1] === "*") {
+      const close = sql.indexOf("*/", i + 2);
+      const end = close === -1 ? sql.length : close + 2;
+      tokens.push({ type: "comment", text: sql.slice(i, end) });
+      i = end;
+      continue;
+    }
+    if (sql[i] === "'") {
+      let j = i + 1;
+      while (j < sql.length) {
+        if (sql[j] === "'" && sql[j + 1] === "'") {
+          j += 2;
+          continue;
+        }
+        if (sql[j] === "'") {
+          j++;
+          break;
+        }
+        j++;
+      }
+      tokens.push({ type: "string", text: sql.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (/[0-9]/.test(sql[i])) {
+      let j = i + 1;
+      while (j < sql.length && /[0-9.]/.test(sql[j])) j++;
+      tokens.push({ type: "number", text: sql.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(sql[i])) {
+      let j = i + 1;
+      while (j < sql.length && /[a-zA-Z0-9_]/.test(sql[j])) j++;
+      const word = sql.slice(i, j);
+      tokens.push({ type: SQL_KW.has(word.toUpperCase()) ? "keyword" : "plain", text: word });
+      i = j;
+      continue;
+    }
+    tokens.push({ type: "plain", text: sql[i] });
+    i++;
+  }
+  return tokens;
+}
+
+// src/ui/theme.ts
+var theme = {
+  accent: "#818cf8",
+  insertMode: "#22d3ee",
+  normalMode: "#ff7722",
+  shellMode: "#4ade80",
+  logo: "#ff9f43",
+  success: "green",
+  error: "red",
+  warning: "yellow",
+  muted: "white"
+};
+
+// src/ui/components/QueryInput.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function FuzzyHighlight({ text, token, selected }) {
+  if (!token) return /* @__PURE__ */ jsx(Text, { dimColor: !selected, children: text });
+  const matched = new Set(fuzzyMatchPositions(token.toLowerCase(), text.toLowerCase()));
+  const segs = [];
+  for (let i = 0; i < text.length; i++) {
+    const hit = matched.has(i);
+    const last = segs[segs.length - 1];
+    if (last && last.hit === hit) last.chars += text[i];
+    else segs.push({ chars: text[i], hit });
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children: segs.map(
+    (seg, i) => seg.hit ? /* @__PURE__ */ jsx(Text, { color: ACCENT, bold: true, children: seg.chars }, i) : /* @__PURE__ */ jsx(Text, { dimColor: !selected, children: seg.chars }, i)
+  ) });
+}
+var BG = "#1e1b4b";
+var ACCENT = "#818cf8";
+var PLACEHOLDER = "#6366f1";
+var KW_COLOR = "#a5b4fc";
+var STR_COLOR = "#fb923c";
+var NUM_COLOR = "#86efac";
+var CMT_COLOR = "#6b7280";
+function sqlTokenColor(type) {
+  if (type === "keyword") return KW_COLOR;
+  if (type === "string") return STR_COLOR;
+  if (type === "number") return NUM_COLOR;
+  if (type === "comment") return CMT_COLOR;
+  return void 0;
+}
+function SqlLine({ text }) {
+  const tokens = tokenizeSql(text);
+  return /* @__PURE__ */ jsx(Fragment, { children: tokens.map((tok, i) => /* @__PURE__ */ jsx(Text, { color: sqlTokenColor(tok.type), children: tok.text }, i)) });
+}
+function SqlHighlightedInput({ text, cursorAt, mode, pad: pad2 }) {
+  const tokens = tokenizeSql(text);
+  const parts = [];
+  let pos = 0;
+  let cursorDone = false;
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i];
+    const tokEnd = pos + tok.text.length;
+    const color = sqlTokenColor(tok.type);
+    if (!cursorDone && cursorAt >= pos && cursorAt < tokEnd) {
+      const rel = cursorAt - pos;
+      const before = tok.text.slice(0, rel);
+      const ch = tok.text[rel];
+      const after = tok.text.slice(rel + 1);
+      if (before) parts.push(/* @__PURE__ */ jsx(Text, { backgroundColor: BG, color, children: before }, `${i}b`));
+      if (mode === "INSERT") {
+        parts.push(/* @__PURE__ */ jsx(Text, { backgroundColor: BG, color: ACCENT, bold: true, children: "\u258C" }, `${i}c`));
+      } else {
+        parts.push(/* @__PURE__ */ jsx(Text, { backgroundColor: ACCENT, color: BG, bold: true, children: ch || " " }, `${i}c`));
+      }
+      if (after) parts.push(/* @__PURE__ */ jsx(Text, { backgroundColor: BG, color, children: after }, `${i}a`));
+      cursorDone = true;
+    } else {
+      parts.push(/* @__PURE__ */ jsx(Text, { backgroundColor: BG, color, children: tok.text }, i));
+    }
+    pos = tokEnd;
+  }
+  if (!cursorDone) {
+    if (mode === "INSERT") {
+      parts.push(/* @__PURE__ */ jsx(Text, { backgroundColor: BG, color: ACCENT, bold: true, children: "\u258C" }, "c"));
+    } else {
+      parts.push(/* @__PURE__ */ jsx(Text, { backgroundColor: ACCENT, color: BG, bold: true, children: " " }, "c"));
+    }
+  }
+  parts.push(/* @__PURE__ */ jsx(Text, { backgroundColor: BG, children: pad2 }, "pad"));
+  return /* @__PURE__ */ jsx(Fragment, { children: parts });
+}
+var HINTS = {
+  INSERT: [
+    ["Esc", "NORMAL MODE"],
+    ["Enter", "RUN QUERY"],
+    ["Ctrl+E", "EDITOR"],
+    ["!cmd", "SHELL"],
+    ["Ctrl+C", "EXIT"]
+  ],
+  NORMAL: [
+    ["i/a/A", "INSERT"],
+    ["h/l", "MOVE"],
+    ["w/b", "WORD"],
+    ["0/$", "LINE ENDS"],
+    ["dd/cc/S", "CLEAR"],
+    ["x/s/dw/cw", "DELETE"],
+    ["D/C", "TO END"],
+    ["e", "EDITOR"]
+  ],
+  PLAIN: [
+    ["Enter", "RUN QUERY"],
+    ["!cmd", "SHELL"],
+    ["Ctrl+C", "EXIT"],
+    ["Ctrl+Z", "BACKGROUND"],
+    ["/toggle-vim-mode", "ENABLE VIM"]
+  ]
+};
+var BUILTIN_DESC_MAP = Object.fromEntries(BUILTIN_COMMAND_LIST.map((c) => [c.name, c.description]));
+function QueryInput({ onSubmit, isLoading, onModeChange, onShellModeChange, vimEnabled = true, history = [], aliases = {}, schema }) {
+  function handleTab(current) {
+    if (!current.startsWith("/")) return null;
+    const partial2 = current.slice(1);
+    const matches = getCompletions(partial2, aliases);
+    if (matches.length === 0) return null;
+    if (matches.length === 1) return `/${matches[0]}`;
+    let prefix = matches[0];
+    for (const m of matches.slice(1)) {
+      while (!m.startsWith(prefix)) prefix = prefix.slice(0, -1);
+      if (!prefix) return null;
+    }
+    return `/${prefix}`;
+  }
+  function handleSuggestionAccept(v, cur, suggestion) {
+    if (v.startsWith("/")) {
+      const val = `/${suggestion}`;
+      return { value: val, cursor: val.length };
+    }
+    return applyCompletion(v, cur, suggestion);
+  }
+  const { value, cursor: cursorPos, mode, suggestionIndex } = useVimInput(
+    onSubmit,
+    !isLoading,
+    vimEnabled,
+    handleTab,
+    history,
+    (v, cur) => v.startsWith("/") ? getCompletions(v.slice(1), aliases) : schema ? getSqlCompletions(v, cur, schema) : [],
+    handleSuggestionAccept
+  );
+  const isShellMode = value.startsWith("!");
+  const isCommand = !isShellMode && value.startsWith("/");
+  const partial = isCommand ? value.slice(1) : "";
+  const suggestions = isCommand ? getCompletions(partial, aliases) : !isShellMode && schema ? getSqlCompletions(value, cursorPos, schema) : [];
+  const sqlToken = isCommand ? "" : getCurrentToken(value, cursorPos);
+  const descMap = {
+    ...BUILTIN_DESC_MAP,
+    ...Object.fromEntries(
+      Object.entries(aliases).map(([name, sql]) => [
+        name,
+        sql.length > 55 ? sql.slice(0, 55) + "\u2026" : sql
+      ])
+    )
+  };
+  useEffect2(() => {
+    onModeChange?.(mode);
+  }, [mode, onModeChange]);
+  useEffect2(() => {
+    onShellModeChange?.(isShellMode);
+  }, [isShellMode, onShellModeChange]);
+  const termWidth = process.stdout.columns ?? 80;
+  const innerWidth = termWidth - 2;
+  const emptyLine = " ".repeat(innerWidth);
+  const isEmpty = value === "";
+  const isMultiLine = !isEmpty && !isShellMode && !isCommand && value.includes("\n");
+  const dOff = isShellMode ? 2 : 0;
+  const placeholder = "Type a SQL query\u2026";
+  const lineWidth = innerWidth - 4;
+  const displayValue = value.slice(dOff);
+  const displayCursor = Math.max(0, cursorPos - dOff);
+  const scrollStart = displayCursor > lineWidth - 1 ? displayCursor - lineWidth + 1 : 0;
+  const visibleBefore = displayValue.slice(scrollStart, displayCursor);
+  const cursorChar = cursorPos < dOff ? " " : displayValue[displayCursor] ?? " ";
+  const visibleAfter = displayValue.slice(displayCursor + 1, scrollStart + lineWidth);
+  const textPad = " ".repeat(Math.max(0, lineWidth - visibleBefore.length - 1 - visibleAfter.length));
+  const visibleSql = value.slice(scrollStart, scrollStart + lineWidth);
+  const relativeSqlCursor = cursorPos - scrollStart;
+  const sqlCursorAtEnd = relativeSqlCursor >= visibleSql.length;
+  const sqlPad = " ".repeat(Math.max(0, lineWidth - visibleSql.length - (sqlCursorAtEnd ? 1 : 0)));
+  const emptyPad = " ".repeat(Math.max(0, lineWidth - placeholder.length - 1));
+  const SEP = "  |  ";
+  const allHints = vimEnabled ? HINTS[mode] : HINTS.PLAIN;
+  const totalHintsWidth = allHints.reduce(
+    (w, [key, desc], i) => w + (i > 0 ? SEP.length : 0) + desc.length + 2 + key.length,
+    0
+  );
+  const hintsInline = totalHintsWidth <= termWidth;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    isMultiLine ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: ACCENT, paddingX: 1, children: value.split("\n").map((line, i, arr) => {
+        const numW = String(arr.length).length;
+        const isLast = i === arr.length - 1;
+        return /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            String(i + 1).padStart(numW),
+            " \u2502 "
+          ] }),
+          /* @__PURE__ */ jsx(SqlLine, { text: line }),
+          isLast && (mode === "INSERT" ? /* @__PURE__ */ jsx(Text, { color: ACCENT, bold: true, children: "\u258C" }) : /* @__PURE__ */ jsx(Text, { backgroundColor: ACCENT, color: BG, bold: true, children: " " }))
+        ] }, i);
+      }) }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Enter: run  \xB7  Ctrl+E / e: re-edit" }) })
+    ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { backgroundColor: BG, children: emptyLine }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { backgroundColor: BG, color: isShellMode ? theme.shellMode : ACCENT, bold: true, children: isShellMode ? "  $ " : "  > " }),
+        isEmpty ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Text, { backgroundColor: BG, color: PLACEHOLDER, children: placeholder }),
+          /* @__PURE__ */ jsx(Text, { backgroundColor: BG, color: ACCENT, bold: true, children: "\u258C" }),
+          /* @__PURE__ */ jsx(Text, { backgroundColor: BG, children: emptyPad })
+        ] }) : isShellMode || isCommand ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Text, { backgroundColor: BG, children: visibleBefore }),
+          mode === "INSERT" ? /* @__PURE__ */ jsx(Text, { backgroundColor: BG, color: ACCENT, bold: true, children: "\u258C" }) : /* @__PURE__ */ jsx(Text, { backgroundColor: ACCENT, color: BG, bold: true, children: cursorChar }),
+          /* @__PURE__ */ jsxs(Text, { backgroundColor: BG, children: [
+            visibleAfter,
+            textPad
+          ] })
+        ] }) : /* @__PURE__ */ jsx(SqlHighlightedInput, { text: visibleSql, cursorAt: relativeSqlCursor, mode, pad: sqlPad })
+      ] }),
+      /* @__PURE__ */ jsx(Text, { backgroundColor: BG, children: emptyLine })
+    ] }),
+    suggestions.length > 0 && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [
+      suggestions.map((name, i) => {
+        const selected = i === suggestionIndex;
+        if (isCommand) {
+          return /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsxs(Text, { children: [
+              /* @__PURE__ */ jsx(Text, { dimColor: !selected, color: selected ? ACCENT : void 0, children: "/" }),
+              /* @__PURE__ */ jsx(FuzzyHighlight, { text: name, token: partial, selected })
+            ] }),
+            /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+              "  \u2014  ",
+              descMap[name]
+            ] })
+          ] }, name);
+        }
+        return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(FuzzyHighlight, { text: name, token: sqlToken, selected }) }, name);
+      }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Tab/\u2191\u2193 navigate  Enter select" })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, flexDirection: hintsInline ? "row" : "column", children: allHints.map(([key, desc], i) => /* @__PURE__ */ jsxs(Text, { children: [
+      hintsInline && i > 0 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  |  " }),
+      /* @__PURE__ */ jsx(Text, { color: ACCENT, bold: true, children: desc }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: `: ${key}` })
+    ] }, desc)) })
+  ] });
+}
+
+// src/ui/components/QueryResult.tsx
+import { useState as useState2, useEffect as useEffect3 } from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+
+// src/ui/components/Table.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var COL_PAD = 1;
+var INDIGO = "#818cf8";
+var BORDER = "white";
+var NULL_COLOR = "#6366f1";
+var NULL_MARKER = "\u2205";
+function isNull(val) {
+  return val === null || val === void 0;
+}
+function cellValue(val) {
+  if (isNull(val)) return NULL_MARKER;
+  if (val instanceof Date) return val.toISOString();
+  if (typeof val === "object") return JSON.stringify(val);
+  return String(val);
+}
+function colWidths(columns, rows) {
+  return columns.map((col) => {
+    const dataMax = rows.reduce(
+      (max, row) => Math.max(max, cellValue(row[col]).length),
+      0
+    );
+    return Math.max(col.length, dataMax);
+  });
+}
+function pad(str, width) {
+  return str.slice(0, width).padEnd(width);
+}
+function hline(widths, left, mid, right) {
+  const segments = widths.map((w) => "\u2500".repeat(w + COL_PAD * 2));
+  return left + segments.join(mid) + right;
+}
+function ExpandedTable({ columns, rows }) {
+  const keyWidth = columns.reduce((max, col) => Math.max(max, col.length), 0);
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: rows.map((row, i) => /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: i < rows.length - 1 ? 1 : 0, children: [
+    /* @__PURE__ */ jsx2(Text2, { color: BORDER, children: `\u2500[ Record ${i + 1} ]${"\u2500".repeat(Math.max(0, keyWidth + 14 - String(i + 1).length))}` }),
+    columns.map((col) => /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: INDIGO, bold: true, children: col.padEnd(keyWidth) }),
+      /* @__PURE__ */ jsx2(Text2, { color: BORDER, children: " \u2502 " }),
+      isNull(row[col]) ? /* @__PURE__ */ jsx2(Text2, { color: NULL_COLOR, dimColor: true, children: NULL_MARKER }) : /* @__PURE__ */ jsx2(Text2, { children: cellValue(row[col]) })
+    ] }, col))
+  ] }, i)) });
+}
+function Table({ columns, rows, expanded = false }) {
+  if (expanded) return /* @__PURE__ */ jsx2(ExpandedTable, { columns, rows });
+  const widths = colWidths(columns, rows);
+  const topLine = hline(widths, "\u256D", "\u252C", "\u256E");
+  const midLine = hline(widths, "\u251C", "\u253C", "\u2524");
+  const botLine = hline(widths, "\u2570", "\u2534", "\u256F");
+  function renderHeaderRow(cols) {
+    return /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: BORDER, children: "\u2502" }),
+      cols.map((v, i) => /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsx2(Text2, { color: INDIGO, bold: true, children: " ".repeat(COL_PAD) + pad(v, widths[i]) + " ".repeat(COL_PAD) }),
+        /* @__PURE__ */ jsx2(Text2, { color: BORDER, children: "\u2502" })
+      ] }, i))
+    ] });
+  }
+  function renderDataRow(row) {
+    return /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: BORDER, children: "\u2502" }),
+      columns.map((col, i) => /* @__PURE__ */ jsxs2(Box2, { children: [
+        isNull(row[col]) ? /* @__PURE__ */ jsx2(Text2, { color: NULL_COLOR, dimColor: true, children: " ".repeat(COL_PAD) + pad(NULL_MARKER, widths[i]) + " ".repeat(COL_PAD) }) : /* @__PURE__ */ jsx2(Text2, { children: " ".repeat(COL_PAD) + pad(cellValue(row[col]), widths[i]) + " ".repeat(COL_PAD) }),
+        /* @__PURE__ */ jsx2(Text2, { color: BORDER, children: "\u2502" })
+      ] }, i))
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Text2, { color: BORDER, children: topLine }),
+    renderHeaderRow(columns),
+    /* @__PURE__ */ jsx2(Text2, { color: BORDER, children: midLine }),
+    rows.map((row, i) => /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      renderDataRow(row),
+      i < rows.length - 1 && /* @__PURE__ */ jsx2(Text2, { color: BORDER, children: midLine })
+    ] }, i)),
+    /* @__PURE__ */ jsx2(Text2, { color: BORDER, children: botLine })
+  ] });
+}
+
+// src/ui/components/QueryResult.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var ERROR_BG = "#3b0f0f";
+var ERROR_FG = "#ff4444";
+function ErrorBox({ message }) {
+  const cols = Math.max(0, (process.stdout.columns ?? 80) - 2);
+  const blank = " ".repeat(cols);
+  const label = `  \u2717  ${message}`;
+  const padded = label.length < cols ? label + " ".repeat(cols - label.length) : label;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx3(Text3, { backgroundColor: ERROR_BG, children: blank }),
+    /* @__PURE__ */ jsx3(Text3, { backgroundColor: ERROR_BG, color: ERROR_FG, bold: true, children: padded }),
+    /* @__PURE__ */ jsx3(Text3, { backgroundColor: ERROR_BG, children: blank })
+  ] });
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function useTerminalWidth() {
+  const [width, setWidth] = useState2(process.stdout.columns ?? 80);
+  useEffect3(() => {
+    const handler = () => setWidth(process.stdout.columns ?? 80);
+    process.stdout.on("resize", handler);
+    return () => {
+      process.stdout.off("resize", handler);
+    };
+  }, []);
+  return width;
+}
+function QueryResult({ state, elapsed, page, pageSize }) {
+  const termWidth = useTerminalWidth();
+  if (state.status === "idle" || state.status === "running") return null;
+  const timing = elapsed !== null ? ` \xB7 ${formatDuration(elapsed)}` : "";
+  if (state.status === "error") {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(ErrorBox, { message: state.message }),
+      elapsed !== null && /* @__PURE__ */ jsx3(Text3, { color: theme.accent, dimColor: true, children: formatDuration(elapsed) })
+    ] });
+  }
+  const { result } = state;
+  const columns = result.fields;
+  if (result.rows.length === 0) {
+    return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { color: theme.accent, children: [
+      "No rows returned (",
+      result.rowCount ?? 0,
+      " affected)",
+      timing
+    ] }) });
+  }
+  const totalRows = result.rows.length;
+  const totalPages = Math.ceil(totalRows / pageSize);
+  const currentPage = Math.min(page, totalPages - 1);
+  const start = currentPage * pageSize;
+  const displayRows = result.rows.slice(start, start + pageSize);
+  const isPaged = totalRows > pageSize;
+  const widths = colWidths(columns, displayRows);
+  const tableWidth = 1 + widths.reduce((sum, w) => sum + w + 3, 0);
+  const expanded = tableWidth > termWidth;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Table, { columns, rows: displayRows, expanded }),
+    /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, flexDirection: "column", children: [
+      isPaged && /* @__PURE__ */ jsxs3(Text3, { color: theme.warning, children: [
+        "Page ",
+        currentPage + 1,
+        " of ",
+        totalPages,
+        " \xB7 showing rows ",
+        start + 1,
+        "\u2013",
+        start + displayRows.length,
+        " of ",
+        totalRows,
+        currentPage > 0 ? "  /prev" : "",
+        currentPage < totalPages - 1 ? "  /next" : ""
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { color: theme.accent, children: [
+        displayRows.length,
+        " row",
+        displayRows.length !== 1 ? "s" : "",
+        timing,
+        expanded ? "  [expanded]" : ""
+      ] })
+    ] })
+  ] });
+}
+
+// src/ui/components/Banner.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { readFileSync as readFileSync5 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join5 } from "path";
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var pkg = { version: "unknown" };
+try {
+  pkg = JSON.parse(readFileSync5(join5(__dirname, "../../../package.json"), "utf8"));
+} catch {
+}
+var LOGO = [
+  " \u2597\u2584\u2584\u2584\u2584\u2584\u2596",
+  "\u2590\u2591 \u25CF \u25CF \u2591\u258C",
+  "\u2590\u2591 \u25E1\u25E1\u25E1 \u2591\u258C",
+  "\u2590\u2591   \u2597\u259F\u258C",
+  " \u2580\u2580\u2580\u2580\u259D\u2580\u2584"
+];
+var GRADIENT = [
+  "#ff00dd",
+  "#ff33bb",
+  "#ff6699",
+  "#ff9966",
+  "#ff7722"
+];
+function Banner({ connectionState }) {
+  const isConnected = connectionState.status === "connected";
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "row", marginTop: 2, marginBottom: 2, children: [
+    /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginRight: 2, children: LOGO.map((line, i) => /* @__PURE__ */ jsx4(Text4, { color: GRADIENT[i], bold: true, children: line }, i)) }),
+    /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text4, { bold: true, color: theme.accent, children: [
+        "Querky ",
+        /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          "v",
+          pkg.version
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx4(Text4, { children: " " }),
+      isConnected ? /* @__PURE__ */ jsxs4(Fragment2, { children: [
+        /* @__PURE__ */ jsxs4(Text4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Connected as  " }),
+          /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.insertMode, children: connectionState.user })
+        ] }),
+        /* @__PURE__ */ jsxs4(Text4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Database      " }),
+          /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.insertMode, children: connectionState.database })
+        ] }),
+        /* @__PURE__ */ jsxs4(Text4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Host          " }),
+          /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.insertMode, children: connectionState.host })
+        ] })
+      ] }) : /* @__PURE__ */ jsxs4(Text4, { color: theme.error, children: [
+        "\u2717 ",
+        connectionState.message
+      ] })
+    ] })
+  ] });
+}
+
+// src/ui/components/App.tsx
+import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var PAGE_SIZE = 50;
+var PLACEHOLDER2 = "#a5b4fc";
+function activePageSize() {
+  return Math.max(3, (process.stdout.rows ?? 24) - 21);
+}
+function limitLines(s, n) {
+  const lines = s.split("\n");
+  if (lines.length <= n) return s;
+  return lines.slice(0, n).join("\n") + `
+\u2026 +${lines.length - n} more lines (scroll up after next submit)`;
+}
+function EntryView({ entry }) {
+  const showAi = entry.aiResponse !== "" || entry.aiError !== null;
+  const isShell = entry.query.startsWith("!");
+  const isCommand = !isShell && (entry.query.startsWith("/") || entry.query.startsWith("\\"));
+  const label = isShell ? "Shell:" : isCommand ? "Command:" : "Query:";
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, paddingX: 1, children: [
+    /* @__PURE__ */ jsxs5(Box5, { borderStyle: "round", borderColor: theme.accent, paddingX: 1, children: [
+      /* @__PURE__ */ jsxs5(Text5, { color: theme.accent, bold: true, children: [
+        label,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: entry.query })
+    ] }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, flexDirection: "column", children: isShell ? entry.shellOutput !== null && /* @__PURE__ */ jsx5(Text5, { children: entry.shellOutput || "(no output)" }) : /* @__PURE__ */ jsxs5(Fragment3, { children: [
+      entry.commandMessage && (entry.commandMessage.ok ? /* @__PURE__ */ jsxs5(Text5, { color: theme.accent, children: [
+        "\u2713 ",
+        entry.commandMessage.text
+      ] }) : /* @__PURE__ */ jsx5(ErrorBox, { message: entry.commandMessage.text })),
+      showAi ? /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx5(Text5, { color: theme.accent, bold: true, children: "Explanation:" }),
+        /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", marginTop: 1, children: entry.aiError ? /* @__PURE__ */ jsx5(ErrorBox, { message: entry.aiError }) : /* @__PURE__ */ jsx5(Text5, { color: PLACEHOLDER2, children: entry.aiResponse }) })
+      ] }) : !entry.commandMessage && /* @__PURE__ */ jsx5(QueryResult, { state: entry.queryState, elapsed: entry.elapsed, page: entry.page, pageSize: PAGE_SIZE })
+    ] }) })
+  ] });
+}
+function App({ connectionState, aiUrl: aiUrl2, aiModel: aiModel2, aiKey: aiKey2, onChangeDatabase }) {
+  const { exit } = useApp();
+  const { isRawModeSupported } = useStdin2();
+  const [queryState, setQueryState] = useState3({ status: "idle" });
+  const [lastQuery, setLastQuery] = useState3("");
+  const [lastSqlQuery, setLastSqlQuery] = useState3("");
+  const [lastResult, setLastResult] = useState3(null);
+  const [page, setPage] = useState3(0);
+  const [vimMode, setVimMode] = useState3("INSERT");
+  const [inputIsShell, setInputIsShell] = useState3(false);
+  const [elapsed, setElapsed] = useState3(null);
+  const [vimEnabled, setVimEnabled] = useState3(true);
+  const [commandMessage, setCommandMessage] = useState3(null);
+  const [history, setHistory] = useState3(() => loadHistory());
+  const [schema, setSchema] = useState3(null);
+  const [aiResponse, setAiResponse] = useState3("");
+  const [isStreaming, setIsStreaming] = useState3(false);
+  const [aiError, setAiError] = useState3(null);
+  const [shellOutput, setShellOutput] = useState3(null);
+  const [isShellRunning, setIsShellRunning] = useState3(false);
+  const [completedEntries, setCompletedEntries] = useState3([]);
+  const entryIdRef = useRef2(0);
+  const aliasScope = connectionState.status === "connected" ? makeScope(connectionState.driver, connectionState.user, connectionState.host, connectionState.database) : "";
+  const [aliases, setAliases] = useState3(
+    () => aliasScope ? getAllAliases(aliasScope) : {}
+  );
+  function handleSaveAlias(name, query) {
+    saveAlias(aliasScope, name, query);
+    setAliases(getAllAliases(aliasScope));
+  }
+  function handleDeleteAlias(name) {
+    const removed = deleteAlias(aliasScope, name);
+    if (removed) setAliases(getAllAliases(aliasScope));
+    return removed;
+  }
+  useEffect4(() => {
+    if (connectionState.status !== "connected") {
+      setSchema(null);
+      return;
+    }
+    void fetchSchema(connectionState.client, connectionState.driver).then(setSchema);
+  }, [connectionState]);
+  useEffect4(() => {
+    if (!isRawModeSupported) return;
+    const ttyStdin = process.stdin;
+    const handleCont = () => ttyStdin.setRawMode?.(true);
+    process.on("SIGCONT", handleCont);
+    return () => {
+      process.off("SIGCONT", handleCont);
+    };
+  }, [isRawModeSupported]);
+  useEffect4(() => {
+    if (!isRawModeSupported) return;
+    process.stdout.write("\x1B[?25l");
+    return () => {
+      process.stdout.write("\x1B[?25h");
+    };
+  }, [isRawModeSupported]);
+  useInput2(
+    (input, key) => {
+      if (key.ctrl && input === "c") exit();
+      if (key.ctrl && input === "z") {
+        const ttyStdin = process.stdin;
+        ttyStdin.setRawMode?.(false);
+        process.kill(process.pid, "SIGTSTP");
+      }
+    },
+    { isActive: isRawModeSupported }
+  );
+  async function handleExplain(query) {
+    setAiResponse("");
+    setAiError(null);
+    setIsStreaming(true);
+    setCommandMessage(null);
+    setQueryState({ status: "idle" });
+    try {
+      for await (const chunk of streamExplain(query, aiUrl2, aiModel2, aiKey2 || void 0)) {
+        setAiResponse((prev) => prev + chunk);
+      }
+    } catch (err) {
+      setAiError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setIsStreaming(false);
+    }
+  }
+  async function handleQuery(sql) {
+    if (connectionState.status !== "connected") return;
+    setAiResponse("");
+    setAiError(null);
+    setCommandMessage(null);
+    setLastQuery(sql);
+    setLastSqlQuery(sql);
+    setElapsed(null);
+    setPage(0);
+    setQueryState({ status: "running" });
+    const updated = addToHistory(history, sql);
+    setHistory(updated);
+    saveHistory(updated);
+    const start = Date.now();
+    const result = await runQuery(connectionState.client, sql);
+    setElapsed(Date.now() - start);
+    setQueryState(result);
+    if (result.status === "success") setLastResult(result.result);
+  }
+  function handleExport(format) {
+    if (!lastResult || lastResult.rows.length === 0) {
+      setCommandMessage({ ok: false, text: "No results to export \u2014 run a query first." });
+      return;
+    }
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const filename = join6(homedir4(), `q-export-${ts}.${format}`);
+    try {
+      if (format === "json") {
+        writeFileSync5(filename, JSON.stringify(lastResult.rows, null, 2));
+      } else {
+        const header = lastResult.fields.join(",");
+        const rows = lastResult.rows.map(
+          (row) => lastResult.fields.map((f) => {
+            const v = row[f];
+            if (v === null || v === void 0) return "";
+            const s = String(v);
+            return s.includes(",") || s.includes('"') || s.includes("\n") ? `"${s.replace(/"/g, '""')}"` : s;
+          }).join(",")
+        );
+        writeFileSync5(filename, [header, ...rows].join("\n"));
+      }
+      setCommandMessage({ ok: true, text: `Exported to ${filename}` });
+    } catch (err) {
+      setCommandMessage({ ok: false, text: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  function snapshotActiveEntry() {
+    if (lastQuery === "") return;
+    setCompletedEntries((prev) => [
+      ...prev,
+      {
+        id: entryIdRef.current++,
+        query: lastQuery,
+        commandMessage,
+        queryState,
+        elapsed,
+        page,
+        aiResponse,
+        aiError,
+        shellOutput
+      }
+    ]);
+  }
+  async function handleShell(cmd) {
+    setShellOutput(null);
+    setIsShellRunning(true);
+    setCommandMessage(null);
+    setAiResponse("");
+    setAiError(null);
+    setQueryState({ status: "idle" });
+    const result = await runShell(cmd);
+    const combined = [result.stdout, result.stderr].filter(Boolean).join("\n");
+    setShellOutput(combined || "(no output)");
+    setIsShellRunning(false);
+  }
+  async function handleSubmit(sql) {
+    if (sql === "/next") {
+      setPage((p) => p + 1);
+      return;
+    }
+    if (sql === "/prev") {
+      setPage((p) => Math.max(0, p - 1));
+      return;
+    }
+    snapshotActiveEntry();
+    if (sql.startsWith("!")) {
+      const cmd = sql.slice(1).trim();
+      setLastQuery(sql);
+      setShellOutput(null);
+      void handleShell(cmd);
+      return;
+    }
+    if (sql.startsWith("/") || sql.startsWith("\\")) {
+      const result = runCommand(sql, {
+        vimEnabled,
+        setVimEnabled,
+        lastSqlQuery,
+        currentDatabase: connectionState.status === "connected" ? connectionState.database : "",
+        driver: connectionState.status === "connected" ? connectionState.driver : "postgresql",
+        onExplain: (query) => {
+          void handleExplain(query);
+        },
+        onQuery: (query) => {
+          void handleQuery(query);
+        },
+        onChangeDatabase: (db) => {
+          onChangeDatabase?.(db);
+        },
+        onExport: handleExport,
+        onClear: () => {
+          process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+          setCompletedEntries([]);
+          setLastQuery("");
+          setCommandMessage(null);
+          setQueryState({ status: "idle" });
+          setShellOutput(null);
+          setAiResponse("");
+          setAiError(null);
+          setElapsed(null);
+          setPage(0);
+        },
+        aliases,
+        onSaveAlias: handleSaveAlias,
+        onDeleteAlias: handleDeleteAlias
+      });
+      if (result.cleared) return;
+      setLastQuery(sql);
+      setAiResponse("");
+      setAiError(null);
+      setElapsed(null);
+      setPage(0);
+      setQueryState({ status: "idle" });
+      if (result.message) setCommandMessage({ ok: result.ok, text: result.message });
+      else setCommandMessage(null);
+      return;
+    }
+    void handleQuery(sql);
+  }
+  const isLoading = queryState.status === "running" || isStreaming || isShellRunning;
+  const isConnected = connectionState.status === "connected";
+  const showAi = aiResponse !== "" || isStreaming || aiError !== null;
+  const isShellEntry = lastQuery.startsWith("!");
+  const isCommand = !isShellEntry && (lastQuery.startsWith("/") || lastQuery.startsWith("\\"));
+  const activeLabel = isShellEntry ? "Shell:" : isCommand ? "Command:" : "Query:";
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Static, { items: completedEntries, children: (entry) => /* @__PURE__ */ jsx5(EntryView, { entry }, entry.id) }),
+    /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, children: [
+      lastQuery === "" && /* @__PURE__ */ jsx5(Banner, { connectionState }),
+      lastQuery !== "" && /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 2, children: [
+        /* @__PURE__ */ jsxs5(Box5, { borderStyle: "round", borderColor: theme.accent, paddingX: 1, children: [
+          /* @__PURE__ */ jsxs5(Text5, { color: theme.accent, bold: true, children: [
+            activeLabel,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: lastQuery })
+        ] }),
+        /* @__PURE__ */ jsx5(Box5, { marginTop: 1, flexDirection: "column", children: isShellEntry ? isShellRunning ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "running\u2026" }) : /* @__PURE__ */ jsx5(Text5, { children: limitLines(shellOutput ?? "", activePageSize()) }) : /* @__PURE__ */ jsxs5(Fragment3, { children: [
+          commandMessage && (commandMessage.ok ? /* @__PURE__ */ jsxs5(Text5, { color: theme.accent, children: [
+            "\u2713 ",
+            commandMessage.text
+          ] }) : /* @__PURE__ */ jsx5(ErrorBox, { message: commandMessage.text })),
+          showAi ? /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsx5(Text5, { color: theme.accent, bold: true, children: "Explanation:" }),
+            /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", marginTop: 1, children: aiError ? /* @__PURE__ */ jsx5(ErrorBox, { message: aiError }) : /* @__PURE__ */ jsxs5(Text5, { color: PLACEHOLDER2, children: [
+              aiResponse,
+              isStreaming && /* @__PURE__ */ jsx5(Text5, { color: PLACEHOLDER2, children: "\u258B" })
+            ] }) })
+          ] }) : !commandMessage && /* @__PURE__ */ jsx5(QueryResult, { state: queryState, elapsed, page, pageSize: activePageSize() })
+        ] }) })
+      ] }),
+      isConnected ? /* @__PURE__ */ jsx5(
+        QueryInput,
+        {
+          onSubmit: handleSubmit,
+          isLoading,
+          onModeChange: setVimMode,
+          onShellModeChange: setInputIsShell,
+          vimEnabled,
+          history,
+          aliases,
+          schema: schema ?? void 0
+        }
+      ) : /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Not connected. Press Ctrl+C to exit." }),
+      (vimEnabled || inputIsShell) && /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { bold: true, color: inputIsShell ? theme.shellMode : vimMode === "NORMAL" ? theme.normalMode : theme.insertMode, children: isRawModeSupported ? inputIsShell ? "[SHELL]" : `[${vimMode}]` : "" }) })
+    ] })
+  ] });
+}
+
+// src/ui/components/ConnectionWizard.tsx
+import { useState as useState4 } from "react";
+import { Box as Box6, Text as Text6, useInput as useInput3, useStdin as useStdin3 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var DRIVERS = ["postgresql", "mysql", "sqlite"];
+var LABEL_WIDTH = 10;
+function fieldLabels(driver) {
+  if (driver === "sqlite") return ["Driver", "File path"];
+  return ["Driver", "Host", "Port", "Database", "User", "Password"];
+}
+function ConnectionWizard({ onConnect, initialError }) {
+  const { isRawModeSupported } = useStdin3();
+  const [focus, setFocus] = useState4(0);
+  const [fields, setFields] = useState4({
+    driver: "postgresql",
+    host: "localhost",
+    port: "5432",
+    database: "",
+    user: "",
+    password: ""
+  });
+  const [connecting, setConnecting] = useState4(false);
+  const [error, setError] = useState4(initialError ?? null);
+  const [keychainHint, setKeychainHint] = useState4(false);
+  const labels = fieldLabels(fields.driver);
+  const fieldCount = labels.length;
+  function getTextValue(idx) {
+    if (fields.driver === "sqlite") {
+      return idx === 1 ? fields.database : "";
+    }
+    switch (idx) {
+      case 1:
+        return fields.host;
+      case 2:
+        return fields.port;
+      case 3:
+        return fields.database;
+      case 4:
+        return fields.user;
+      case 5:
+        return fields.password;
+      default:
+        return "";
+    }
+  }
+  function setTextValue(idx, value) {
+    setFields((prev) => {
+      if (prev.driver === "sqlite") {
+        return idx === 1 ? { ...prev, database: value } : prev;
+      }
+      switch (idx) {
+        case 1:
+          return { ...prev, host: value };
+        case 2:
+          return { ...prev, port: value };
+        case 3:
+          return { ...prev, database: value };
+        case 4:
+          return { ...prev, user: value };
+        case 5:
+          return { ...prev, password: value };
+        default:
+          return prev;
+      }
+    });
+  }
+  function cycleDriver(dir) {
+    setFields((prev) => {
+      const idx = DRIVERS.indexOf(prev.driver);
+      const next = DRIVERS[(idx + dir + DRIVERS.length) % DRIVERS.length];
+      const port = next === "mysql" ? "3306" : next === "postgresql" ? "5432" : "0";
+      return { ...prev, driver: next, port };
+    });
+    setFocus(0);
+  }
+  function moveFocus(next) {
+    setFocus(next);
+    if (fields.driver !== "sqlite" && next === 5 && !fields.password) {
+      void getPassword(
+        fields.driver,
+        fields.user,
+        fields.host,
+        parseInt(fields.port) || (fields.driver === "mysql" ? 3306 : 5432)
+      ).then((saved) => {
+        if (saved) {
+          setFields((prev) => ({ ...prev, password: saved }));
+          setKeychainHint(true);
+        }
+      });
+    } else {
+      setKeychainHint(false);
+    }
+  }
+  async function submit() {
+    setConnecting(true);
+    setError(null);
+    setKeychainHint(false);
+    const result = await connectParams({
+      driver: fields.driver,
+      host: fields.host || "localhost",
+      port: parseInt(fields.port) || (fields.driver === "mysql" ? 3306 : 5432),
+      database: fields.database,
+      user: fields.user,
+      password: fields.password
+    });
+    setConnecting(false);
+    if (result.status === "error") {
+      setError(result.message);
+    } else {
+      onConnect(result);
+    }
+  }
+  useInput3(
+    (input, key) => {
+      if (connecting) return;
+      if (key.tab && key.shift) {
+        moveFocus((focus - 1 + fieldCount) % fieldCount);
+        return;
+      }
+      if (key.tab || key.downArrow) {
+        moveFocus((focus + 1) % fieldCount);
+        return;
+      }
+      if (key.upArrow) {
+        moveFocus((focus - 1 + fieldCount) % fieldCount);
+        return;
+      }
+      if (focus === 0) {
+        if (key.leftArrow) cycleDriver(-1);
+        if (key.rightArrow || input === " ") cycleDriver(1);
+        if (key.return) moveFocus(1);
+        return;
+      }
+      if (key.return) {
+        if (focus === fieldCount - 1) {
+          void submit();
+        } else {
+          moveFocus(focus + 1);
+        }
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setKeychainHint(false);
+        setTextValue(focus, getTextValue(focus).slice(0, -1));
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        if (keychainHint) {
+          setKeychainHint(false);
+          setTextValue(focus, input);
+        } else {
+          setTextValue(focus, getTextValue(focus) + input);
+        }
+      }
+    },
+    { isActive: isRawModeSupported }
+  );
+  const isPassword = (idx) => fields.driver !== "sqlite" && idx === 5;
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 2, paddingTop: 2, paddingBottom: 1, children: [
+    /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { bold: true, color: theme.accent, children: "Connect to a database" }) }),
+    labels.map((label, idx) => {
+      const isFocused = focus === idx;
+      const isDriver = idx === 0;
+      return /* @__PURE__ */ jsxs6(Box6, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: isFocused ? theme.accent : void 0, bold: isFocused, children: label.padEnd(LABEL_WIDTH) }),
+        isDriver ? /* @__PURE__ */ jsx6(Box6, { children: DRIVERS.map((d, i) => /* @__PURE__ */ jsxs6(Box6, { children: [
+          i > 0 && /* @__PURE__ */ jsx6(Text6, { children: "   " }),
+          /* @__PURE__ */ jsxs6(Text6, { color: fields.driver === d ? theme.accent : void 0, bold: fields.driver === d, children: [
+            fields.driver === d ? "\u25CF " : "\u25CB ",
+            d.charAt(0).toUpperCase() + d.slice(1)
+          ] })
+        ] }, d)) }) : /* @__PURE__ */ jsxs6(Box6, { children: [
+          /* @__PURE__ */ jsx6(Text6, { children: isPassword(idx) ? "\u2022".repeat(getTextValue(idx).length) : getTextValue(idx) }),
+          isFocused && /* @__PURE__ */ jsx6(Text6, { color: theme.accent, bold: true, children: "\u258C" }),
+          isFocused && isPassword(idx) && keychainHint && /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  (from keychain)" })
+        ] })
+      ] }, label);
+    }),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: connecting ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Connecting\u2026" }) : error ? /* @__PURE__ */ jsxs6(Text6, { color: theme.error, children: [
+      "\u2717 ",
+      error
+    ] }) : null }),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Tab \xB7 \u2191\u2193 navigate   Enter connect   \u2190\u2192 cycle driver" }) })
+  ] });
+}
+
+// src/index.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var { values } = parseArgs({
+  args: process.argv.slice(2).filter((a) => a !== "--"),
+  options: {
+    connection: { type: "string", short: "c" },
+    "ai-url": { type: "string", default: "http://localhost:11434/v1" },
+    "ai-model": { type: "string", default: "llama3.2" },
+    "api-key": { type: "string", default: "" }
+  },
+  strict: false
+});
+var initialDsn = values.connection;
+var aiUrl = values["ai-url"];
+var aiModel = values["ai-model"];
+var aiKey = values["api-key"] || process.env.Q_CLI_API_KEY || "";
+function Root({ initialDsn: initialDsn2, aiUrl: aiUrl2, aiModel: aiModel2, aiKey: aiKey2 }) {
+  const [connectionState, setConnectionState] = useState5(null);
+  const [dsnError, setDsnError] = useState5(null);
+  useEffect5(() => {
+    if (initialDsn2) {
+      connectDsn(initialDsn2).then((state) => {
+        if (state.status === "error") {
+          setDsnError(state.message);
+        } else {
+          setConnectionState(state);
+        }
+      });
+    }
+  }, []);
+  if (initialDsn2 && !connectionState && !dsnError) {
+    return /* @__PURE__ */ jsx7(Box7, { paddingX: 2, paddingTop: 1, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Connecting\u2026" }) });
+  }
+  if (!connectionState) {
+    return /* @__PURE__ */ jsx7(ConnectionWizard, { onConnect: setConnectionState, initialError: dsnError ?? void 0 });
+  }
+  async function handleChangeDatabase(database) {
+    if (connectionState.status !== "connected") return;
+    const current = connectionState;
+    await current.client.end().catch(() => {
+    });
+    const next = await connectParams({ ...current.params, database });
+    setConnectionState(next);
+  }
+  return /* @__PURE__ */ jsx7(
+    App,
+    {
+      connectionState,
+      aiUrl: aiUrl2,
+      aiModel: aiModel2,
+      aiKey: aiKey2,
+      onChangeDatabase: (db) => {
+        void handleChangeDatabase(db);
+      }
+    }
+  );
+}
+render(
+  /* @__PURE__ */ jsx7(Root, { initialDsn, aiUrl, aiModel, aiKey }),
+  { exitOnCtrlC: true }
+);