@lunaperegrina/meowdb 0.0.1

package/README.md

@@ -0,0 +1,39 @@
+# meowdb CLI
+
+```text
+ /\_/\\
+( o.o )   meow meow database explorer ~
+ > ^ <
+```
+
+A tiny, cute terminal app to explore PostgreSQL databases quickly. (´｡• ᵕ •｡`)
+
+## Features
+
+- Save multiple PostgreSQL connections and keep one active.
+- Add and switch databases with slash commands: `/add`, `/list`, `/tables`.
+- Browse tables from the active database in a split-view UI.
+- Preview table rows (up to 50 by default) with horizontal/vertical scrolling.
+- Navigate with keyboard and mouse wheel/click support.
+
+## Install
+
+```bash
+npm install -g meowdb
+```
+
+## Development
+
+```bash
+npm run dev
+```
+
+## Run
+
+```bash
+meowdb
+```
+
+```text
+(=^-ω-^=)  happy querying!
+```

package/dist/bundle.js

@@ -0,0 +1,1137 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { render } from "ink";
+
+// src/app.tsx
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useInput, useStdout } from "ink";
+
+// src/storage/databases.ts
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var CONFIG_DIRECTORY = path.join(os.homedir(), ".config", "meowdb");
+var DATABASES_FILE = path.join(CONFIG_DIRECTORY, "databases.json");
+var createDefaultState = () => ({
+  activeDatabaseId: null,
+  databases: []
+});
+var isObject = (value) => typeof value === "object" && value !== null;
+var isDatabaseEntry = (value) => {
+  if (!isObject(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.name === "string" && typeof value.postgresUrl === "string" && typeof value.createdAt === "string" && typeof value.updatedAt === "string";
+};
+var normalizeState = (value) => {
+  if (!isObject(value) || !Array.isArray(value.databases)) {
+    throw new Error("Arquivo de databases inv\xE1lido.");
+  }
+  const databases = value.databases.filter(isDatabaseEntry);
+  const activeDatabaseId = typeof value.activeDatabaseId === "string" ? value.activeDatabaseId : null;
+  const hasActiveDatabase = activeDatabaseId !== null && databases.some((database) => database.id === activeDatabaseId);
+  return {
+    activeDatabaseId: hasActiveDatabase ? activeDatabaseId : null,
+    databases
+  };
+};
+var ensureStorage = async () => {
+  await fs.mkdir(CONFIG_DIRECTORY, { recursive: true });
+  try {
+    await fs.access(DATABASES_FILE);
+  } catch (error) {
+    const nodeError = error;
+    if (nodeError.code !== "ENOENT") {
+      throw error;
+    }
+    await fs.writeFile(DATABASES_FILE, `${JSON.stringify(createDefaultState(), null, 2)}
+`, "utf8");
+  }
+};
+var readState = async () => {
+  await ensureStorage();
+  const rawContent = await fs.readFile(DATABASES_FILE, "utf8");
+  const parsedContent = JSON.parse(rawContent);
+  return normalizeState(parsedContent);
+};
+var writeState = async (state) => {
+  await ensureStorage();
+  await fs.writeFile(DATABASES_FILE, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+};
+var getState = async () => readState();
+var addDatabase = async (input) => {
+  const state = await readState();
+  const name = input.name.trim();
+  const postgresUrl = input.postgresUrl.trim();
+  if (name.length === 0) {
+    throw new Error("Nome \xE9 obrigat\xF3rio.");
+  }
+  if (postgresUrl.length === 0) {
+    throw new Error("Postgres URL \xE9 obrigat\xF3ria.");
+  }
+  const hasValidPrefix = postgresUrl.startsWith("postgres://") || postgresUrl.startsWith("postgresql://");
+  if (!hasValidPrefix) {
+    throw new Error("Postgres URL deve come\xE7ar com postgres:// ou postgresql://.");
+  }
+  const duplicatedName = state.databases.some(
+    (database) => database.name.toLowerCase() === name.toLowerCase()
+  );
+  if (duplicatedName) {
+    throw new Error("J\xE1 existe uma database com esse nome.");
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const newDatabase = {
+    id: randomUUID(),
+    name,
+    postgresUrl,
+    createdAt: timestamp,
+    updatedAt: timestamp
+  };
+  const nextState = {
+    activeDatabaseId: newDatabase.id,
+    databases: [...state.databases, newDatabase]
+  };
+  await writeState(nextState);
+  return nextState;
+};
+var setActiveDatabase = async (databaseId) => {
+  const state = await readState();
+  const hasDatabase = state.databases.some((database) => database.id === databaseId);
+  if (!hasDatabase) {
+    throw new Error("Database selecionada n\xE3o existe.");
+  }
+  const nextState = {
+    ...state,
+    activeDatabaseId: databaseId
+  };
+  await writeState(nextState);
+  return nextState;
+};
+
+// src/storage/postgres.ts
+import { Client } from "pg";
+var DEFAULT_ROWS_LIMIT = 50;
+var normalizeLimit = (limit) => {
+  if (!Number.isFinite(limit)) {
+    return DEFAULT_ROWS_LIMIT;
+  }
+  return Math.max(1, Math.floor(limit));
+};
+var escapeIdentifier = (value) => `"${value.replaceAll('"', '""')}"`;
+var withClient = async (postgresUrl, callback) => {
+  const client = new Client({ connectionString: postgresUrl });
+  await client.connect();
+  try {
+    return await callback(client);
+  } finally {
+    await client.end();
+  }
+};
+var listTables = async (postgresUrl) => withClient(postgresUrl, async (client) => {
+  const result = await client.query(
+    `SELECT table_schema, table_name
+       FROM information_schema.tables
+       WHERE table_type = 'BASE TABLE'
+         AND table_schema NOT IN ('pg_catalog', 'information_schema')
+       ORDER BY table_schema ASC, table_name ASC`
+  );
+  return result.rows.map((row) => ({
+    schema: row.table_schema,
+    name: row.table_name,
+    qualifiedName: `${row.table_schema}.${row.table_name}`
+  }));
+});
+var listTableRows = async (postgresUrl, schema, table, limit = DEFAULT_ROWS_LIMIT) => withClient(postgresUrl, async (client) => {
+  const normalizedLimit = normalizeLimit(limit);
+  const schemaIdentifier = escapeIdentifier(schema);
+  const tableIdentifier = escapeIdentifier(table);
+  const query = `SELECT * FROM ${schemaIdentifier}.${tableIdentifier} LIMIT $1`;
+  const result = await client.query(query, [normalizedLimit]);
+  const columns = result.fields.map((field) => field.name);
+  const rows = result.rows.map((row) => {
+    const normalizedRow = {};
+    for (const column of columns) {
+      normalizedRow[column] = row[column];
+    }
+    return normalizedRow;
+  });
+  return {
+    columns,
+    rows,
+    limit: normalizedLimit
+  };
+});
+
+// src/app.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var FALLBACK_COLUMNS = 80;
+var FALLBACK_ROWS = 24;
+var STATUS_BAR_HEIGHT = 1;
+var INPUT_BAR_HEIGHT = 5;
+var MODAL_HEIGHT = 9;
+var SPLIT_GAP = 2;
+var SIDEBAR_MIN_WIDTH = 24;
+var SIDEBAR_MAX_WIDTH = 44;
+var CONTENT_MIN_WIDTH = 20;
+var ROWS_PREVIEW_LIMIT = 50;
+var ROW_NUMBER_WIDTH = 4;
+var CELL_MIN_WIDTH = 8;
+var CELL_MAX_WIDTH = 24;
+var CELL_SEPARATOR = " | ";
+var MAIN_BACKGROUND = "#0B1020";
+var SURFACE_BACKGROUND = "#131A2A";
+var PRIMARY_TEXT = "#F3F6FC";
+var SECONDARY_TEXT = "#8C97B2";
+var getTerminalSize = (stdout) => ({
+  columns: stdout.columns && stdout.columns > 0 ? stdout.columns : FALLBACK_COLUMNS,
+  rows: stdout.rows && stdout.rows > 0 ? stdout.rows : FALLBACK_ROWS
+});
+var getSplitPaneSizes = (terminalColumns, hasActiveDatabase) => {
+  const mainWidth = Math.max(24, terminalColumns - 2);
+  if (!hasActiveDatabase) {
+    return {
+      mainWidth,
+      sidebarWidth: 0,
+      contentWidth: mainWidth
+    };
+  }
+  const preferredSidebar = Math.floor(mainWidth * 0.34);
+  const boundedSidebar = Math.min(
+    SIDEBAR_MAX_WIDTH,
+    Math.max(SIDEBAR_MIN_WIDTH, preferredSidebar)
+  );
+  const maxSidebarForContent = Math.max(
+    SIDEBAR_MIN_WIDTH,
+    mainWidth - CONTENT_MIN_WIDTH - SPLIT_GAP
+  );
+  const sidebarWidth = Math.min(boundedSidebar, maxSidebarForContent);
+  const contentWidth = Math.max(
+    CONTENT_MIN_WIDTH,
+    mainWidth - sidebarWidth - SPLIT_GAP
+  );
+  return {
+    mainWidth,
+    sidebarWidth,
+    contentWidth
+  };
+};
+var slashCommands = [
+  { id: "add", label: "add", description: "Add database" },
+  { id: "list", label: "list", description: "List databases" },
+  { id: "tables", label: "tables", description: "Reload tables for active database" }
+];
+var isNavigationKey = (key) => Boolean(
+  key.tab || key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.pageUp || key.pageDown || key.escape
+);
+var normalizeInput = (value) => value.replaceAll(/\r?\n/g, "");
+var ESCAPE_INPUT = "\x1B";
+var ENABLE_MOUSE_TRACKING = "\x1B[?1000h\x1B[?1006h";
+var DISABLE_MOUSE_TRACKING = "\x1B[?1000l\x1B[?1002l\x1B[?1003l\x1B[?1005l\x1B[?1006l\x1B[?1015l";
+var SGR_MOUSE_PACKET_PATTERN = /(?:\u001B)?\[<(\d+);(\d+);(\d+)([Mm])/g;
+var wrapIndex = (index, total) => {
+  if (total <= 0) {
+    return 0;
+  }
+  if (index < 0) {
+    return total - 1;
+  }
+  if (index >= total) {
+    return 0;
+  }
+  return index;
+};
+var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+var parseSgrMousePacket = (buttonCodeRaw, xRaw, yRaw, marker) => {
+  const buttonCode = Number.parseInt(buttonCodeRaw, 10);
+  const x = Number.parseInt(xRaw, 10);
+  const y = Number.parseInt(yRaw, 10);
+  if (Number.isNaN(buttonCode) || Number.isNaN(x) || Number.isNaN(y) || x <= 0 || y <= 0) {
+    return null;
+  }
+  if ((buttonCode & 64) === 64) {
+    return {
+      type: (buttonCode & 1) === 1 ? "wheelDown" : "wheelUp",
+      x: x - 1,
+      y: y - 1
+    };
+  }
+  const isButtonPress = marker === "M";
+  const isMotion = (buttonCode & 32) === 32;
+  const isLeftButton = (buttonCode & 3) === 0;
+  if (isButtonPress && !isMotion && isLeftButton) {
+    return {
+      type: "leftClick",
+      x: x - 1,
+      y: y - 1
+    };
+  }
+  return null;
+};
+var parseSgrMouseInput = (input) => {
+  const events = [];
+  let hasPacket = false;
+  let consumedLength = 0;
+  SGR_MOUSE_PACKET_PATTERN.lastIndex = 0;
+  let match = SGR_MOUSE_PACKET_PATTERN.exec(input);
+  while (match) {
+    if (match.index !== consumedLength) {
+      return {
+        consumed: false,
+        events: []
+      };
+    }
+    hasPacket = true;
+    consumedLength += match[0].length;
+    const parsedEvent = parseSgrMousePacket(match[1], match[2], match[3], match[4]);
+    if (parsedEvent) {
+      events.push(parsedEvent);
+    }
+    match = SGR_MOUSE_PACKET_PATTERN.exec(input);
+  }
+  if (!hasPacket || consumedLength !== input.length) {
+    return {
+      consumed: false,
+      events: []
+    };
+  }
+  return {
+    consumed: true,
+    events
+  };
+};
+var truncateText = (value, maxLength) => {
+  if (maxLength <= 1) {
+    return value.length > 0 ? "\u2026" : "";
+  }
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength - 1)}\u2026`;
+};
+var padCell = (value, width) => truncateText(value, width).padEnd(width, " ");
+var formatCellValue = (value) => {
+  if (value === null) {
+    return "null";
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (typeof value === "string") {
+    return value.replaceAll(/\r?\n/g, " ");
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) {
+      return String(value);
+    }
+    return serialized.replaceAll(/\r?\n/g, " ");
+  } catch {
+    return String(value);
+  }
+};
+var getErrorMessage = (error) => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Erro desconhecido.";
+};
+var getRowsViewport = (terminalColumns, totalColumns, requestedOffset) => {
+  if (totalColumns <= 0) {
+    return {
+      cellWidth: CELL_MIN_WIDTH,
+      visibleColumnCount: 0,
+      maxOffset: 0,
+      offset: 0
+    };
+  }
+  const innerWidth = Math.max(24, terminalColumns - 8);
+  const availableForCells = Math.max(
+    1,
+    innerWidth - ROW_NUMBER_WIDTH - CELL_SEPARATOR.length
+  );
+  const maxVisibleColumnCount = Math.max(
+    1,
+    Math.floor(
+      (availableForCells + CELL_SEPARATOR.length) / (CELL_MIN_WIDTH + CELL_SEPARATOR.length)
+    )
+  );
+  const visibleColumnCount = Math.min(totalColumns, maxVisibleColumnCount);
+  const separatorsWidth = CELL_SEPARATOR.length * Math.max(0, visibleColumnCount - 1);
+  const cellWidth = Math.min(
+    CELL_MAX_WIDTH,
+    Math.max(
+      CELL_MIN_WIDTH,
+      Math.floor((availableForCells - separatorsWidth) / visibleColumnCount)
+    )
+  );
+  const maxOffset = Math.max(0, totalColumns - visibleColumnCount);
+  const offset = Math.min(Math.max(0, requestedOffset), maxOffset);
+  return {
+    cellWidth,
+    visibleColumnCount,
+    maxOffset,
+    offset
+  };
+};
+var INITIAL_DATABASE_STATE = {
+  activeDatabaseId: null,
+  databases: []
+};
+function App() {
+  const { stdout } = useStdout();
+  const [messages, setMessages] = useState([]);
+  const [draft, setDraft] = useState("");
+  const [mode, setMode] = useState("chat");
+  const [slashQuery, setSlashQuery] = useState("");
+  const [slashIndex, setSlashIndex] = useState(0);
+  const [formField, setFormField] = useState("name");
+  const [formName, setFormName] = useState("");
+  const [formPostgresUrl, setFormPostgresUrl] = useState("");
+  const [listIndex, setListIndex] = useState(0);
+  const [databaseState, setDatabaseState] = useState(INITIAL_DATABASE_STATE);
+  const [isLoadingDatabases, setIsLoadingDatabases] = useState(true);
+  const [isSavingDatabase, setIsSavingDatabase] = useState(false);
+  const [isSettingActive, setIsSettingActive] = useState(false);
+  const [tables, setTables] = useState([]);
+  const [tablesIndex, setTablesIndex] = useState(0);
+  const [isLoadingTables, setIsLoadingTables] = useState(false);
+  const [tablesError, setTablesError] = useState(null);
+  const [selectedTable, setSelectedTable] = useState(null);
+  const [rowsPreview, setRowsPreview] = useState(null);
+  const [rowsError, setRowsError] = useState(null);
+  const [rowsColumnOffset, setRowsColumnOffset] = useState(0);
+  const [rowsWindowStart, setRowsWindowStart] = useState(0);
+  const [isLoadingRows, setIsLoadingRows] = useState(false);
+  const tablesLoadIdRef = useRef(0);
+  const rowsLoadIdRef = useRef(0);
+  const [terminalSize, setTerminalSize] = useState(() => getTerminalSize(stdout));
+  const rowsCount = rowsPreview?.rows.length ?? 0;
+  const rowsColumnCount = rowsPreview?.columns.length ?? 0;
+  useEffect(() => {
+    const handleResize = () => {
+      setTerminalSize(getTerminalSize(stdout));
+    };
+    stdout.on("resize", handleResize);
+    return () => {
+      stdout.off("resize", handleResize);
+    };
+  }, [stdout]);
+  useEffect(() => {
+    if (!stdout.isTTY) {
+      return;
+    }
+    const disableMouseTracking = () => {
+      stdout.write(DISABLE_MOUSE_TRACKING);
+    };
+    stdout.write(ENABLE_MOUSE_TRACKING);
+    process.on("beforeExit", disableMouseTracking);
+    process.on("exit", disableMouseTracking);
+    return () => {
+      process.off("beforeExit", disableMouseTracking);
+      process.off("exit", disableMouseTracking);
+      disableMouseTracking();
+    };
+  }, [stdout]);
+  useEffect(() => {
+    let mounted = true;
+    const bootstrapDatabaseState = async () => {
+      try {
+        const state = await getState();
+        if (!mounted) {
+          return;
+        }
+        setDatabaseState(state);
+      } catch (error) {
+        if (!mounted) {
+          return;
+        }
+        setMessages((previous) => [
+          ...previous,
+          `Erro ao carregar databases: ${getErrorMessage(error)}`
+        ]);
+      } finally {
+        if (mounted) {
+          setIsLoadingDatabases(false);
+        }
+      }
+    };
+    void bootstrapDatabaseState();
+    return () => {
+      mounted = false;
+    };
+  }, []);
+  const pushMessage = (message) => {
+    setMessages((previous) => [...previous, message]);
+  };
+  const filteredCommands = useMemo(() => {
+    const query = slashQuery.trim().toLowerCase();
+    if (query.length === 0) {
+      return slashCommands;
+    }
+    return slashCommands.filter(
+      (command) => command.label.toLowerCase().includes(query)
+    );
+  }, [slashQuery]);
+  useEffect(() => {
+    setSlashIndex((previous) => wrapIndex(previous, filteredCommands.length));
+  }, [filteredCommands.length]);
+  useEffect(() => {
+    setListIndex((previous) => wrapIndex(previous, databaseState.databases.length));
+  }, [databaseState.databases.length]);
+  useEffect(() => {
+    setTablesIndex((previous) => wrapIndex(previous, tables.length));
+  }, [tables.length]);
+  useEffect(() => {
+    if (rowsColumnCount === 0) {
+      if (rowsColumnOffset !== 0) {
+        setRowsColumnOffset(0);
+      }
+      return;
+    }
+    const splitPaneSizes2 = getSplitPaneSizes(
+      terminalSize.columns,
+      databaseState.activeDatabaseId !== null
+    );
+    const viewport = getRowsViewport(
+      splitPaneSizes2.contentWidth,
+      rowsColumnCount,
+      rowsColumnOffset
+    );
+    if (viewport.offset !== rowsColumnOffset) {
+      setRowsColumnOffset(viewport.offset);
+    }
+  }, [
+    databaseState.activeDatabaseId,
+    rowsColumnCount,
+    rowsColumnOffset,
+    terminalSize.columns
+  ]);
+  const activeDatabase = useMemo(
+    () => databaseState.databases.find(
+      (database) => database.id === databaseState.activeDatabaseId
+    ) ?? null,
+    [databaseState]
+  );
+  const resetRowsState = useCallback(() => {
+    rowsLoadIdRef.current += 1;
+    setSelectedTable(null);
+    setRowsPreview(null);
+    setRowsError(null);
+    setRowsColumnOffset(0);
+    setRowsWindowStart(0);
+    setIsLoadingRows(false);
+  }, []);
+  const loadTablesForDatabase = useCallback(
+    async (database) => {
+      const loadId = tablesLoadIdRef.current + 1;
+      tablesLoadIdRef.current = loadId;
+      setTables([]);
+      setTablesIndex(0);
+      setTablesError(null);
+      resetRowsState();
+      if (!database) {
+        setIsLoadingTables(false);
+        return;
+      }
+      setIsLoadingTables(true);
+      try {
+        const nextTables = await listTables(database.postgresUrl);
+        if (tablesLoadIdRef.current !== loadId) {
+          return;
+        }
+        setTables(nextTables);
+        setTablesIndex(0);
+      } catch (error) {
+        if (tablesLoadIdRef.current !== loadId) {
+          return;
+        }
+        setTablesError(getErrorMessage(error));
+      } finally {
+        if (tablesLoadIdRef.current === loadId) {
+          setIsLoadingTables(false);
+        }
+      }
+    },
+    [resetRowsState]
+  );
+  useEffect(() => {
+    void loadTablesForDatabase(activeDatabase);
+  }, [activeDatabase, loadTablesForDatabase]);
+  const openListModal = () => {
+    const activeIndex = databaseState.databases.findIndex(
+      (database) => database.id === databaseState.activeDatabaseId
+    );
+    setListIndex(activeIndex >= 0 ? activeIndex : 0);
+    setMode("listModal");
+    setDraft("");
+    setSlashQuery("");
+    setSlashIndex(0);
+  };
+  const closeSlashMenu = () => {
+    setMode("chat");
+    setSlashQuery("");
+    setSlashIndex(0);
+  };
+  const loadRowsForTable = useCallback(async (table) => {
+    if (!activeDatabase) {
+      return;
+    }
+    const loadId = rowsLoadIdRef.current + 1;
+    rowsLoadIdRef.current = loadId;
+    setSelectedTable(table);
+    setRowsPreview(null);
+    setRowsError(null);
+    setRowsColumnOffset(0);
+    setRowsWindowStart(0);
+    setIsLoadingRows(true);
+    try {
+      const preview = await listTableRows(
+        activeDatabase.postgresUrl,
+        table.schema,
+        table.name,
+        ROWS_PREVIEW_LIMIT
+      );
+      if (rowsLoadIdRef.current !== loadId) {
+        return;
+      }
+      setRowsPreview(preview);
+    } catch (error) {
+      if (rowsLoadIdRef.current !== loadId) {
+        return;
+      }
+      setRowsError(getErrorMessage(error));
+    } finally {
+      if (rowsLoadIdRef.current === loadId) {
+        setIsLoadingRows(false);
+      }
+    }
+  }, [activeDatabase]);
+  const loadRowsForSelectedTable = useCallback(async () => {
+    const table = tables[tablesIndex];
+    if (!table) {
+      return;
+    }
+    await loadRowsForTable(table);
+  }, [loadRowsForTable, tables, tablesIndex]);
+  const selectSlashCommand = () => {
+    const selectedCommand = filteredCommands[slashIndex];
+    if (!selectedCommand) {
+      pushMessage("Nenhum comando encontrado.");
+      closeSlashMenu();
+      return;
+    }
+    if (selectedCommand.id === "add") {
+      setMode("addForm");
+      setFormField("name");
+      setFormName("");
+      setFormPostgresUrl("");
+      setDraft("");
+      setSlashQuery("");
+      setSlashIndex(0);
+      return;
+    }
+    if (selectedCommand.id === "list") {
+      openListModal();
+      return;
+    }
+    closeSlashMenu();
+    if (!activeDatabase) {
+      pushMessage("Nenhuma database ativa. Use /add ou /list para selecionar uma database.");
+      return;
+    }
+    void loadTablesForDatabase(activeDatabase);
+  };
+  const submitAddForm = async () => {
+    if (isSavingDatabase) {
+      return;
+    }
+    setIsSavingDatabase(true);
+    try {
+      const state = await addDatabase({
+        name: formName,
+        postgresUrl: formPostgresUrl
+      });
+      const createdDatabase = state.databases.find((database) => database.id === state.activeDatabaseId) ?? null;
+      setDatabaseState(state);
+      setMode("chat");
+      setFormField("name");
+      setFormName("");
+      setFormPostgresUrl("");
+      pushMessage(
+        createdDatabase ? `Database "${createdDatabase.name}" salva e ativada.` : "Database salva e ativada."
+      );
+    } catch (error) {
+      pushMessage(`Erro ao salvar database: ${getErrorMessage(error)}`);
+    } finally {
+      setIsSavingDatabase(false);
+    }
+  };
+  const activateSelectedDatabase = async () => {
+    if (isSettingActive || databaseState.databases.length === 0) {
+      return;
+    }
+    const selectedDatabase = databaseState.databases[listIndex];
+    if (!selectedDatabase) {
+      return;
+    }
+    setIsSettingActive(true);
+    try {
+      const state = await setActiveDatabase(selectedDatabase.id);
+      setDatabaseState(state);
+      setMode("chat");
+      pushMessage(`Database ativa: ${selectedDatabase.name}`);
+    } catch (error) {
+      pushMessage(`Erro ao ativar database: ${getErrorMessage(error)}`);
+    } finally {
+      setIsSettingActive(false);
+    }
+  };
+  useInput((input, key) => {
+    const parsedMouseInput = parseSgrMouseInput(input);
+    if (parsedMouseInput.consumed) {
+      if (mode !== "chat" || !hasActiveDatabase) {
+        return;
+      }
+      const splitPaneX = 1;
+      const splitPaneY = 1;
+      const sidebarXStart = splitPaneX;
+      const sidebarXEnd = sidebarXStart + splitPaneSizes.sidebarWidth;
+      const tablesListYStart = splitPaneY + 1;
+      const tablesListYEnd = tablesListYStart + visibleTables.length;
+      const contentXStart = sidebarXEnd + SPLIT_GAP;
+      const contentXEnd = contentXStart + splitPaneSizes.contentWidth;
+      const contentYStart = splitPaneY + 1;
+      const contentYEnd = contentYStart + Math.max(0, mainViewportRows - 1);
+      for (const mouseEvent of parsedMouseInput.events) {
+        const isWithinSidebar = mouseEvent.x >= sidebarXStart && mouseEvent.x < sidebarXEnd && mouseEvent.y >= splitPaneY && mouseEvent.y < splitPaneY + mainViewportRows;
+        if (isWithinSidebar) {
+          if ((mouseEvent.type === "wheelUp" || mouseEvent.type === "wheelDown") && !isLoadingTables && tables.length > 0) {
+            const delta = mouseEvent.type === "wheelDown" ? 1 : -1;
+            setTablesIndex((previous) => clamp(previous + delta, 0, tables.length - 1));
+          }
+          if (mouseEvent.type === "leftClick" && !isLoadingTables && mouseEvent.y >= tablesListYStart && mouseEvent.y < tablesListYEnd) {
+            const relativeIndex = mouseEvent.y - tablesListYStart;
+            const absoluteIndex = tablesWindowStart + relativeIndex;
+            const table = tables[absoluteIndex];
+            if (table) {
+              setTablesIndex(absoluteIndex);
+              void loadRowsForTable(table);
+            }
+          }
+          continue;
+        }
+        const isWithinContent = mouseEvent.x >= contentXStart && mouseEvent.x < contentXEnd && mouseEvent.y >= contentYStart && mouseEvent.y < contentYEnd;
+        if (isWithinContent && (mouseEvent.type === "wheelUp" || mouseEvent.type === "wheelDown") && rowsPreview && !isLoadingRows) {
+          const delta = mouseEvent.type === "wheelDown" ? 1 : -1;
+          setRowsWindowStart(
+            (previous) => clamp(previous + delta, 0, maxRowsWindowStart)
+          );
+        }
+      }
+      return;
+    }
+    const isEscapePressed = key.escape || input === ESCAPE_INPUT;
+    if (isEscapePressed) {
+      if (mode === "slashMenu") {
+        closeSlashMenu();
+        return;
+      }
+      if (mode === "addForm") {
+        setMode("chat");
+        setFormField("name");
+        return;
+      }
+      if (mode === "listModal") {
+        setMode("chat");
+        return;
+      }
+    }
+    if (key.ctrl || key.meta) {
+      return;
+    }
+    const cleanedInput = normalizeInput(input);
+    if (mode === "slashMenu") {
+      if (key.return) {
+        selectSlashCommand();
+        return;
+      }
+      if (key.upArrow) {
+        setSlashIndex((previous) => wrapIndex(previous - 1, filteredCommands.length));
+        return;
+      }
+      if (key.downArrow || key.tab) {
+        setSlashIndex((previous) => wrapIndex(previous + 1, filteredCommands.length));
+        return;
+      }
+      if (key.backspace || key.delete) {
+        if (slashQuery.length === 0) {
+          closeSlashMenu();
+          return;
+        }
+        setSlashQuery((previous) => previous.slice(0, -1));
+        setSlashIndex(0);
+        return;
+      }
+      if (isNavigationKey(key)) {
+        return;
+      }
+      if (cleanedInput.length > 0 && cleanedInput !== "/") {
+        setSlashQuery((previous) => previous + cleanedInput);
+        setSlashIndex(0);
+      }
+      return;
+    }
+    if (mode === "addForm") {
+      if (key.tab || key.upArrow || key.downArrow) {
+        setFormField((previous) => previous === "name" ? "postgresUrl" : "name");
+        return;
+      }
+      if (key.return) {
+        void submitAddForm();
+        return;
+      }
+      if (key.backspace || key.delete) {
+        if (formField === "name") {
+          setFormName((previous) => previous.slice(0, -1));
+        } else {
+          setFormPostgresUrl((previous) => previous.slice(0, -1));
+        }
+        return;
+      }
+      if (isNavigationKey(key)) {
+        return;
+      }
+      if (cleanedInput.length > 0) {
+        if (formField === "name") {
+          setFormName((previous) => previous + cleanedInput);
+        } else {
+          setFormPostgresUrl((previous) => previous + cleanedInput);
+        }
+      }
+      return;
+    }
+    if (mode === "listModal") {
+      if (key.upArrow) {
+        setListIndex((previous) => wrapIndex(previous - 1, databaseState.databases.length));
+        return;
+      }
+      if (key.downArrow || key.tab) {
+        setListIndex((previous) => wrapIndex(previous + 1, databaseState.databases.length));
+        return;
+      }
+      if (key.return) {
+        void activateSelectedDatabase();
+      }
+      return;
+    }
+    if (key.upArrow) {
+      if (!isLoadingTables && tables.length > 0) {
+        setTablesIndex((previous) => wrapIndex(previous - 1, tables.length));
+      }
+      return;
+    }
+    if (key.downArrow || key.tab) {
+      if (!isLoadingTables && tables.length > 0) {
+        setTablesIndex((previous) => wrapIndex(previous + 1, tables.length));
+      }
+      return;
+    }
+    if (key.leftArrow) {
+      if (rowsPreview) {
+        setRowsColumnOffset((previous) => Math.max(0, previous - 1));
+      }
+      return;
+    }
+    if (key.rightArrow) {
+      if (rowsPreview) {
+        setRowsColumnOffset((previous) => Math.min(rowsViewport.maxOffset, previous + 1));
+      }
+      return;
+    }
+    if (input === "/" && draft.length === 0) {
+      setMode("slashMenu");
+      setSlashQuery("");
+      setSlashIndex(0);
+      return;
+    }
+    if (key.return) {
+      const message = draft.trim();
+      if (message.length > 0) {
+        setMessages((previous) => [...previous, message]);
+        setDraft("");
+        return;
+      }
+      if (!isLoadingRows && !isLoadingTables && activeDatabase && tables.length > 0) {
+        void loadRowsForSelectedTable();
+      }
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setDraft((previous) => previous.slice(0, -1));
+      return;
+    }
+    if (key.escape || key.pageUp || key.pageDown) {
+      return;
+    }
+    if (cleanedInput.length > 0) {
+      setDraft((previous) => previous + cleanedInput);
+    }
+  });
+  const modalRows = mode === "slashMenu" || mode === "addForm" || mode === "listModal" ? MODAL_HEIGHT : 0;
+  const mainViewportRows = Math.max(
+    1,
+    terminalSize.rows - INPUT_BAR_HEIGHT - STATUS_BAR_HEIGHT - modalRows - 2
+  );
+  const visibleMessages = messages.slice(-mainViewportRows);
+  const hasActiveDatabase = activeDatabase !== null;
+  const splitPaneSizes = useMemo(
+    () => getSplitPaneSizes(terminalSize.columns, hasActiveDatabase),
+    [hasActiveDatabase, terminalSize.columns]
+  );
+  const inputLabel = mode === "chat" ? `\u203A ${draft}` : mode === "slashMenu" ? `\u203A /${slashQuery}` : mode === "addForm" ? "\u203A preenchendo formul\xE1rio de database" : "\u203A selecionando database ativa";
+  const dbIndicator = isLoadingDatabases ? "loading..." : activeDatabase ? `${activeDatabase.name}` : "none";
+  const listEntries = databaseState.databases;
+  const listMaxUrlLength = Math.max(12, terminalSize.columns - 18);
+  const tableNameMaxLength = Math.max(10, splitPaneSizes.sidebarWidth - 4);
+  const selectedSidebarTable = tables[tablesIndex] ?? null;
+  const rowsViewport = useMemo(() => {
+    if (!rowsPreview) {
+      return {
+        cellWidth: CELL_MIN_WIDTH,
+        visibleColumnCount: 0,
+        maxOffset: 0,
+        offset: 0,
+        visibleColumns: []
+      };
+    }
+    const viewport = getRowsViewport(
+      splitPaneSizes.contentWidth,
+      rowsPreview.columns.length,
+      rowsColumnOffset
+    );
+    return {
+      ...viewport,
+      visibleColumns: rowsPreview.columns.slice(
+        viewport.offset,
+        viewport.offset + viewport.visibleColumnCount
+      )
+    };
+  }, [rowsPreview, rowsColumnOffset, splitPaneSizes.contentWidth]);
+  const rowsHeaderLine = useMemo(() => {
+    if (rowsViewport.visibleColumns.length === 0) {
+      return "";
+    }
+    const headerColumns = rowsViewport.visibleColumns.map((column) => padCell(column, rowsViewport.cellWidth)).join(CELL_SEPARATOR);
+    return `${padCell("row", ROW_NUMBER_WIDTH)}${CELL_SEPARATOR}${headerColumns}`;
+  }, [rowsViewport]);
+  const rowsWindowSize = Math.max(1, mainViewportRows - 6);
+  const maxRowsWindowStart = Math.max(0, rowsCount - rowsWindowSize);
+  useEffect(() => {
+    setRowsWindowStart((previous) => clamp(previous, 0, maxRowsWindowStart));
+  }, [maxRowsWindowStart]);
+  const visibleRows = rowsPreview ? rowsPreview.rows.slice(rowsWindowStart, rowsWindowStart + rowsWindowSize) : [];
+  const visibleRowsStart = visibleRows.length > 0 ? rowsWindowStart + 1 : 0;
+  const visibleRowsEnd = rowsWindowStart + visibleRows.length;
+  const tablesWindowSize = Math.max(1, mainViewportRows - 4);
+  const maxTablesWindowStart = Math.max(0, tables.length - tablesWindowSize);
+  const tablesWindowStart = Math.min(
+    maxTablesWindowStart,
+    Math.max(0, tablesIndex - Math.floor(tablesWindowSize / 2))
+  );
+  const visibleTables = tables.slice(
+    tablesWindowStart,
+    tablesWindowStart + tablesWindowSize
+  );
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      width: terminalSize.columns,
+      height: terminalSize.rows,
+      children: [
+        /* @__PURE__ */ jsx(
+          Box,
+          {
+            flexDirection: "column",
+            flexGrow: 1,
+            width: terminalSize.columns,
+            padding: 1,
+            overflow: "hidden",
+            backgroundColor: MAIN_BACKGROUND,
+            children: hasActiveDatabase ? /* @__PURE__ */ jsxs(Box, { flexDirection: "row", flexGrow: 1, overflow: "hidden", children: [
+              /* @__PURE__ */ jsxs(
+                Box,
+                {
+                  flexDirection: "column",
+                  width: splitPaneSizes.sidebarWidth,
+                  overflow: "hidden",
+                  children: [
+                    /* @__PURE__ */ jsx(Text, { bold: true, color: PRIMARY_TEXT, children: `Tables \u2022 ${truncateText(activeDatabase?.name ?? "", Math.max(10, splitPaneSizes.sidebarWidth - 12))}` }),
+                    isLoadingTables ? /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: "Carregando tabelas..." }) : tablesError ? /* @__PURE__ */ jsx(Text, { color: "red", children: `Erro ao carregar tabelas: ${tablesError}` }) : tables.length === 0 ? /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: "Nenhuma tabela encontrada." }) : visibleTables.map((table, index) => {
+                      const absoluteIndex = tablesWindowStart + index;
+                      const isSelected = absoluteIndex === tablesIndex;
+                      return /* @__PURE__ */ jsx(Text, { color: isSelected ? "magenta" : PRIMARY_TEXT, children: `${isSelected ? "\u203A" : " "} ${truncateText(table.qualifiedName, tableNameMaxLength)}` }, table.qualifiedName);
+                    }),
+                    /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: tables.length > 0 ? `${tablesIndex + 1}/${tables.length} \u2022 enter/click carrega rows` : "use /tables para recarregar" })
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsx(Box, { width: SPLIT_GAP }),
+              /* @__PURE__ */ jsxs(
+                Box,
+                {
+                  flexDirection: "column",
+                  flexGrow: 1,
+                  width: splitPaneSizes.contentWidth,
+                  overflow: "hidden",
+                  children: [
+                    /* @__PURE__ */ jsx(Text, { bold: true, color: PRIMARY_TEXT, children: selectedTable ? `Rows \u2022 ${truncateText(selectedTable.qualifiedName, Math.max(10, splitPaneSizes.contentWidth - 12))}` : selectedSidebarTable ? `Rows \u2022 ${truncateText(selectedSidebarTable.qualifiedName, Math.max(10, splitPaneSizes.contentWidth - 12))}` : "Rows" }),
+                    isLoadingRows ? /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: "Carregando rows..." }) : rowsError ? /* @__PURE__ */ jsx(Text, { color: "red", children: `Erro ao carregar rows: ${rowsError}` }) : !selectedTable || !rowsPreview ? /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: "Clique ou selecione uma table na sidebar para carregar rows." }) : rowsViewport.visibleColumns.length === 0 ? /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: "N\xE3o h\xE1 colunas para exibir." }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+                      /* @__PURE__ */ jsx(Text, { color: "cyan", children: rowsHeaderLine }),
+                      rowsPreview.rows.length === 0 ? /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: "Sem rows para exibir." }) : visibleRows.map((row, index) => {
+                        const absoluteIndex = rowsWindowStart + index;
+                        const rowLabel = padCell(String(absoluteIndex + 1), ROW_NUMBER_WIDTH);
+                        const rowCells = rowsViewport.visibleColumns.map((column) => padCell(formatCellValue(row[column]), rowsViewport.cellWidth)).join(CELL_SEPARATOR);
+                        const rowLine = `${rowLabel}${CELL_SEPARATOR}${rowCells}`;
+                        return /* @__PURE__ */ jsx(Text, { color: PRIMARY_TEXT, children: rowLine }, `${absoluteIndex}-${rowLine}`);
+                      }),
+                      /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: `rows ${visibleRowsStart}-${visibleRowsEnd}/${rowsCount} (limit ${rowsPreview.limit})` }),
+                      /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: `colunas ${rowsViewport.offset + 1}-${rowsViewport.offset + rowsViewport.visibleColumns.length}/${rowsPreview.columns.length}` })
+                    ] }),
+                    /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: "\u2191/\u2193 tables \u2022 click carrega rows \u2022 wheel sidebar/rows \u2022 \u2190/\u2192 colunas" })
+                  ]
+                }
+              )
+            ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+              visibleMessages.length === 0 ? /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: "Digite / para abrir o slash menu." }) : null,
+              visibleMessages.map((message, index) => /* @__PURE__ */ jsx(Text, { color: PRIMARY_TEXT, children: message }, `${index}-${message}`))
+            ] })
+          }
+        ),
+        mode === "slashMenu" ? /* @__PURE__ */ jsx(
+          Box,
+          {
+            width: terminalSize.columns,
+            paddingX: 1,
+            paddingBottom: 1,
+            backgroundColor: MAIN_BACKGROUND,
+            children: /* @__PURE__ */ jsx(
+              Box,
+              {
+                flexDirection: "column",
+                borderStyle: "round",
+                borderColor: "cyan",
+                paddingX: 1,
+                width: Math.max(24, terminalSize.columns - 2),
+                height: MODAL_HEIGHT,
+                children: filteredCommands.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "red", children: "Nenhum comando encontrado." }) : filteredCommands.map((command, index) => {
+                  const isSelected = index === slashIndex;
+                  return /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
+                    /* @__PURE__ */ jsx(Text, { color: isSelected ? "cyan" : PRIMARY_TEXT, children: `${isSelected ? "\u203A" : " "} /${command.label}` }),
+                    /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: command.description })
+                  ] }, command.id);
+                })
+              }
+            )
+          }
+        ) : null,
+        mode === "addForm" ? /* @__PURE__ */ jsx(
+          Box,
+          {
+            width: terminalSize.columns,
+            paddingX: 1,
+            paddingBottom: 1,
+            backgroundColor: MAIN_BACKGROUND,
+            children: /* @__PURE__ */ jsxs(
+              Box,
+              {
+                flexDirection: "column",
+                borderStyle: "round",
+                borderColor: "green",
+                paddingX: 1,
+                width: Math.max(24, terminalSize.columns - 2),
+                height: MODAL_HEIGHT,
+                children: [
+                  /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
+                    /* @__PURE__ */ jsx(Text, { bold: true, color: PRIMARY_TEXT, children: "Add database" }),
+                    /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: "esc" })
+                  ] }),
+                  /* @__PURE__ */ jsx(Text, { color: formField === "name" ? "green" : PRIMARY_TEXT, children: `name: ${formField === "name" ? "\u203A" : " "} ${formName.length > 0 ? formName : "..."}` }),
+                  /* @__PURE__ */ jsx(Text, { color: formField === "postgresUrl" ? "green" : PRIMARY_TEXT, children: `postgresURL: ${formField === "postgresUrl" ? "\u203A" : " "} ${formPostgresUrl.length > 0 ? formPostgresUrl : "..."}` }),
+                  /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: "tab alterna campo \u2022 enter salva \u2022 esc cancela" }),
+                  /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: isSavingDatabase ? "Salvando database..." : "URL aceita: postgres:// ou postgresql://" })
+                ]
+              }
+            )
+          }
+        ) : null,
+        mode === "listModal" ? /* @__PURE__ */ jsx(
+          Box,
+          {
+            width: terminalSize.columns,
+            paddingX: 1,
+            paddingBottom: 1,
+            backgroundColor: MAIN_BACKGROUND,
+            children: /* @__PURE__ */ jsxs(
+              Box,
+              {
+                flexDirection: "column",
+                borderStyle: "round",
+                borderColor: "yellow",
+                paddingX: 1,
+                width: Math.max(24, terminalSize.columns - 2),
+                height: MODAL_HEIGHT,
+                children: [
+                  /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
+                    /* @__PURE__ */ jsx(Text, { bold: true, color: PRIMARY_TEXT, children: "Databases" }),
+                    /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: "esc" })
+                  ] }),
+                  listEntries.length === 0 ? /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: "Nenhuma database cadastrada." }) : listEntries.map((database, index) => {
+                    const isSelected = index === listIndex;
+                    const isActive = database.id === databaseState.activeDatabaseId;
+                    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+                      /* @__PURE__ */ jsx(Text, { color: isSelected ? "yellow" : PRIMARY_TEXT, children: `${isSelected ? "\u203A" : " "} ${database.name}${isActive ? " (active)" : ""}` }),
+                      /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: `   ${truncateText(database.postgresUrl, listMaxUrlLength)}` })
+                    ] }, database.id);
+                  }),
+                  /* @__PURE__ */ jsx(Text, { color: SECONDARY_TEXT, children: isSettingActive && "Ativando database..." })
+                ]
+              }
+            )
+          }
+        ) : null,
+        /* @__PURE__ */ jsxs(
+          Box,
+          {
+            width: terminalSize.columns,
+            height: INPUT_BAR_HEIGHT,
+            padding: 1,
+            backgroundColor: SURFACE_BACKGROUND,
+            flexDirection: "column",
+            justifyContent: "space-between",
+            children: [
+              /* @__PURE__ */ jsx(Text, { color: PRIMARY_TEXT, children: inputLabel }),
+              /* @__PURE__ */ jsxs(Text, { color: PRIMARY_TEXT, children: [
+                /* @__PURE__ */ jsx(Text, { color: "green", children: "Database " }),
+                dbIndicator
+              ] })
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/index.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+render(/* @__PURE__ */ jsx2(App, {}));

package/package.json

@@ -0,0 +1,31 @@
+{
+	"name": "@lunaperegrina/meowdb",
+	"version": "0.0.1",
+	"license": "MIT",
+	"bin": "dist/bundle.js",
+	"type": "module",
+	"engines": {
+		"node": ">=16"
+	},
+	"scripts": {
+		"build": "rm -rf dist && tsc --noEmit && esbuild src/index.tsx --bundle --platform=node --format=esm --packages=external --outfile=dist/bundle.js",
+		"local": "npm run build && npm link",
+		"dev": "bun --hot src/index.tsx"
+	},
+	"files": [
+		"dist"
+	],
+	"dependencies": {
+		"@types/react": "^19.2.14",
+		"ink": "^6.8.0",
+		"pg": "^8.20.0",
+		"react": "^19.2.4"
+	},
+	"devDependencies": {
+		"@types/node": "^25.5.0",
+		"@types/pg": "^8.18.0",
+		"esbuild": "^0.27.4",
+		"ts-node": "^10.9.2",
+		"typescript": "^5.9.3"
+	}
+}