quickerquery 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1,100 @@
+# QuickQuery
+
+A terminal-based database query tool inspired by JetBrains DataGrip. Query databases directly from the terminal with syntax highlighting, result tables, and connection management—without leaving your workflow.
+
+## Features
+
+- **PostgreSQL support** - Connect to PostgreSQL databases via JDBC URL
+- **Syntax highlighting** - SQL editor with code highlighting in the terminal
+- **Secure authentication** - Masked password input for secure credential entry
+- **Keyboard-driven** - Fast, distraction-free interface built for developers
+- **Lightweight** - Minimal dependencies, quick startup time
+
+## Installation
+
+```bash
+# Install globally via npm
+npm install -g quickerquery
+
+# Or with pnpm
+pnpm add -g quickerquery
+```
+
+## Usage
+
+```bash
+qq <database-url>
+```
+
+### Example
+
+```bash
+qq jdbc:postgresql://localhost:5432/mydb
+```
+
+The tool will prompt you for:
+1. **Username** - Your database username
+2. **Password** - Your database password (input is masked)
+
+Once connected, you'll have a SQL editor where you can write and execute queries.
+
+### Controls
+
+- **Enter** - Execute query
+- **Ctrl+C** - Exit the application
+
+## Development
+
+### Prerequisites
+
+- Node.js 22+
+- pnpm
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/your-username/quickquery.git
+cd quickquery
+
+# Install dependencies
+pnpm install
+
+# Run in development mode
+pnpm dev
+
+# Build for production
+pnpm build
+
+# Run the built version
+pnpm start
+```
+
+### Scripts
+
+| Command | Description |
+|---------|-------------|
+| `pnpm dev` | Run in development mode with hot reload |
+| `pnpm build` | Compile TypeScript to JavaScript |
+| `pnpm start` | Run the compiled application |
+
+## Tech Stack
+
+- **React** + **Ink** - Terminal UI framework
+- **TypeScript** - Type-safe development
+- **pg** - PostgreSQL client
+- **ink-mini-code-editor** - Syntax-highlighted code editor for terminal
+
+## Roadmap
+
+- [ ] Query execution and result display
+- [ ] Query history
+- [ ] Multi-line query support
+- [ ] Result pagination
+- [ ] MySQL support
+- [ ] SQLite support
+- [ ] Connection profiles/saved connections
+
+## License
+
+MIT

package/dist/components/QueryResults.d.ts

@@ -0,0 +1,7 @@
+import { type QueryResultData } from '../types.js';
+interface QueryResultsProps {
+    data: QueryResultData;
+    onBack: () => void;
+}
+export declare const QueryResults: ({ data, onBack }: QueryResultsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/QueryResults.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useMemo } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import { ResultHeader } from './ResultHeader.js';
+import { ResultRow } from './ResultRow.js';
+import { ResultFooter } from './ResultFooter.js';
+import { ScrollIndicator } from './ScrollIndicator.js';
+import { fitColumnsToWidth, calculateTableWidth } from '../types.js';
+const DEFAULT_VISIBLE_ROWS = 15;
+const PAGE_SIZE = 10;
+export const QueryResults = ({ data, onBack }) => {
+    const { stdout } = useStdout();
+    const [view, setView] = useState({ selectedRow: 0, scrollOffset: 0 });
+    // Get terminal dimensions
+    const terminalHeight = stdout?.rows ?? 24;
+    const terminalWidth = stdout?.columns ?? 80;
+    // Calculate visible rows based on terminal height (reserve space for header/footer)
+    const visibleRows = Math.max(5, Math.min(DEFAULT_VISIBLE_ROWS, terminalHeight - 12));
+    // Fit columns to terminal width (memoized to avoid recalculating on every render)
+    const fittedColumns = useMemo(() => fitColumnsToWidth(data.columns, terminalWidth - 2), // -2 for scroll indicator
+    [data.columns, terminalWidth]);
+    // Check if terminal is too narrow to display anything useful
+    const minRequiredWidth = calculateTableWidth(data.columns.map((c) => ({ ...c, width: 3 })) // Minimum 3 chars per column
+    );
+    const isTooNarrow = terminalWidth < minRequiredWidth + 2;
+    const maxScroll = Math.max(0, data.rows.length - visibleRows);
+    const lastRow = data.rows.length - 1;
+    // Helper to update view state while keeping selection in viewport
+    const navigate = (newSelected) => {
+        setView((prev) => {
+            const selected = Math.max(0, Math.min(lastRow, newSelected));
+            let offset = prev.scrollOffset;
+            // Scroll up if selection moves above viewport
+            if (selected < offset) {
+                offset = selected;
+            }
+            // Scroll down if selection moves below viewport
+            else if (selected >= offset + visibleRows) {
+                offset = Math.min(maxScroll, selected - visibleRows + 1);
+            }
+            return { selectedRow: selected, scrollOffset: offset };
+        });
+    };
+    useInput((input, key) => {
+        if (input === 'q' || key.escape) {
+            onBack();
+            return;
+        }
+        if (key.upArrow) {
+            navigate(view.selectedRow - 1);
+        }
+        if (key.downArrow) {
+            navigate(view.selectedRow + 1);
+        }
+        if (key.pageUp) {
+            navigate(view.selectedRow - PAGE_SIZE);
+        }
+        if (key.pageDown) {
+            navigate(view.selectedRow + PAGE_SIZE);
+        }
+        // Home - go to first row
+        if (key.ctrl && input === 'a') {
+            navigate(0);
+        }
+        // End - go to last row
+        if (key.ctrl && input === 'e') {
+            navigate(lastRow);
+        }
+    });
+    const { selectedRow, scrollOffset } = view;
+    const visibleData = data.rows.slice(scrollOffset, scrollOffset + visibleRows);
+    // Terminal too narrow to display table
+    if (isTooNarrow) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { color: "yellow", children: "Terminal too narrow to display results." }), _jsxs(Text, { dimColor: true, children: ["Need at least ", minRequiredWidth + 2, " columns, have ", terminalWidth, "."] }), _jsx(Text, { dimColor: true, children: "Resize terminal or reduce number of columns in query." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press q to go back" }) })] }));
+    }
+    if (data.rows.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { color: "yellow", children: "Query executed successfully." }), _jsx(Text, { dimColor: true, children: "No rows returned." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press q to go back" }) })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ResultHeader, { columns: fittedColumns }), _jsxs(Box, { children: [_jsx(Box, { flexDirection: "column", children: visibleData.map((row, idx) => (_jsx(ResultRow, { row: row, columns: fittedColumns, isSelected: scrollOffset + idx === selectedRow }, scrollOffset + idx))) }), _jsx(ScrollIndicator, { currentRow: scrollOffset, visibleRows: visibleRows, totalRows: data.rows.length })] }), _jsx(ResultFooter, { columns: fittedColumns, rowCount: data.rowCount, executionTime: data.executionTime, viewStart: scrollOffset, viewEnd: scrollOffset + visibleRows })] }));
+};

package/dist/components/ResultCell.d.ts

@@ -0,0 +1,6 @@
+interface ResultCellProps {
+    value: unknown;
+    width: number;
+}
+export declare const ResultCell: ({ value, width }: ResultCellProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ResultCell.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { formatValue, getCellType, padCell } from '../types.js';
+export const ResultCell = ({ value, width }) => {
+    const type = getCellType(value);
+    const formatted = formatValue(value);
+    const padded = padCell(formatted, width, type);
+    return (_jsx(Text, { color: getCellColor(type), dimColor: type === 'null', children: padded }));
+};
+function getCellColor(type) {
+    switch (type) {
+        case 'null':
+            return 'gray';
+        case 'number':
+            return 'cyan';
+        case 'boolean':
+            return 'yellow';
+        case 'date':
+            return 'magenta';
+        case 'json':
+            return 'green';
+        default:
+            return undefined;
+    }
+}

package/dist/components/ResultFooter.d.ts

@@ -0,0 +1,10 @@
+import type { ColumnInfo } from '../types.js';
+interface ResultFooterProps {
+    columns: ColumnInfo[];
+    rowCount: number;
+    executionTime: number;
+    viewStart: number;
+    viewEnd: number;
+}
+export declare const ResultFooter: ({ columns, rowCount, executionTime, viewStart, viewEnd }: ResultFooterProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ResultFooter.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export const ResultFooter = ({ columns, rowCount, executionTime, viewStart, viewEnd }) => {
+    const bottomBorder = buildBorder(columns, '└', '┴', '┘');
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "gray", children: ' ' + bottomBorder }), _jsxs(Box, { marginTop: 1, gap: 2, children: [_jsxs(Text, { dimColor: true, children: ["Showing ", viewStart + 1, "-", Math.min(viewEnd, rowCount), " of ", rowCount, " rows"] }), _jsxs(Text, { dimColor: true, children: ["(", executionTime.toFixed(0), "ms)"] })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "\u2191\u2193 scroll \u2022 PgUp/PgDn page \u2022 q back to query" }) })] }));
+};
+function buildBorder(columns, left, mid, right) {
+    const segments = columns.map((col) => '─'.repeat(col.width + 2));
+    return left + segments.join(mid) + right;
+}

package/dist/components/ResultHeader.d.ts

@@ -0,0 +1,6 @@
+import type { ColumnInfo } from '../types.js';
+interface ResultHeaderProps {
+    columns: ColumnInfo[];
+}
+export declare const ResultHeader: ({ columns }: ResultHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ResultHeader.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { truncate } from '../types.js';
+export const ResultHeader = ({ columns }) => {
+    const topBorder = buildBorder(columns, '┌', '┬', '┐');
+    const bottomBorder = buildBorder(columns, '├', '┼', '┤');
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "gray", children: ' ' + topBorder }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: "gray", children: "\u2502" }), columns.map((col) => (_jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { bold: true, color: "white", children: truncate(col.name, col.width).padEnd(col.width) }), _jsx(Text, { children: " " }), _jsx(Text, { color: "gray", children: "\u2502" })] }, col.name)))] }), _jsx(Text, { color: "gray", children: ' ' + bottomBorder })] }));
+};
+function buildBorder(columns, left, mid, right) {
+    const segments = columns.map((col) => '─'.repeat(col.width + 2));
+    return left + segments.join(mid) + right;
+}

package/dist/components/ResultRow.d.ts

@@ -0,0 +1,8 @@
+import type { ColumnInfo } from '../types.js';
+interface ResultRowProps {
+    row: Record<string, unknown>;
+    columns: ColumnInfo[];
+    isSelected?: boolean;
+}
+export declare const ResultRow: ({ row, columns, isSelected }: ResultRowProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ResultRow.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { ResultCell } from './ResultCell.js';
+export const ResultRow = ({ row, columns, isSelected = false }) => {
+    return (_jsxs(Box, { children: [_jsx(Text, { children: isSelected ? '▶' : ' ' }), _jsx(Text, { color: "gray", children: "\u2502" }), columns.map((col, idx) => (_jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(ResultCell, { value: row[col.name], width: col.width }), _jsx(Text, { children: " " }), _jsx(Text, { color: "gray", children: "\u2502" })] }, col.name)))] }));
+};

package/dist/components/ScrollIndicator.d.ts

@@ -0,0 +1,7 @@
+interface ScrollIndicatorProps {
+    currentRow: number;
+    visibleRows: number;
+    totalRows: number;
+}
+export declare const ScrollIndicator: ({ currentRow, visibleRows, totalRows }: ScrollIndicatorProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/ScrollIndicator.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export const ScrollIndicator = ({ currentRow, visibleRows, totalRows }) => {
+    if (totalRows <= visibleRows) {
+        return null;
+    }
+    const scrollbarHeight = Math.max(1, Math.floor((visibleRows / totalRows) * visibleRows));
+    const scrollPosition = Math.floor((currentRow / (totalRows - visibleRows)) * (visibleRows - scrollbarHeight));
+    const lines = [];
+    for (let i = 0; i < visibleRows; i++) {
+        if (i >= scrollPosition && i < scrollPosition + scrollbarHeight) {
+            lines.push('█');
+        }
+        else {
+            lines.push('░');
+        }
+    }
+    return (_jsx(Box, { flexDirection: "column", marginLeft: 1, children: lines.map((char, idx) => (_jsx(Text, { color: "gray", children: char }, idx))) }));
+};

package/dist/components/index.d.ts

@@ -0,0 +1,6 @@
+export { QueryResults } from './QueryResults.js';
+export { ResultHeader } from './ResultHeader.js';
+export { ResultRow } from './ResultRow.js';
+export { ResultCell } from './ResultCell.js';
+export { ResultFooter } from './ResultFooter.js';
+export { ScrollIndicator } from './ScrollIndicator.js';

package/dist/components/index.js

@@ -0,0 +1,6 @@
+export { QueryResults } from './QueryResults.js';
+export { ResultHeader } from './ResultHeader.js';
+export { ResultRow } from './ResultRow.js';
+export { ResultCell } from './ResultCell.js';
+export { ResultFooter } from './ResultFooter.js';
+export { ScrollIndicator } from './ScrollIndicator.js';

package/dist/index.js

@@ -4,6 +4,9 @@ import { useState, useEffect } from 'react';
 import { render, Box, Text, useApp, useInput } from 'ink';
 import TextInput from 'ink-mini-code-editor';
 import pg from 'pg';
+import { QueryResults } from './components/index.js';
+import { parseQueryResult } from './types.js';
+import { TEST_QUERY_RESULT } from './testdata.js';
 function parseJdbcUrl(url) {
     // Parse jdbc:postgresql://host:port/database
     const match = url.match(/^jdbc:postgresql:\/\/([^:]+):(\d+)\/(.+)$/);
@@ -24,6 +27,8 @@ const App = ({ config }) => {
     const [error, setError] = useState('');
     const [client, setClient] = useState(null);
     const [query, setQuery] = useState('SELECT 1');
+    const [results, setResults] = useState(null);
+    const [queryError, setQueryError] = useState('');
     useInput((input, key) => {
         if (key.ctrl && input === 'c') {
             if (client) {
@@ -65,8 +70,26 @@ const App = ({ config }) => {
         };
     }, [state, config, username, password]);
     const handleQuerySubmit = async () => {
-        // Query execution will be implemented next
-        console.log('Query:', query);
+        if (!client || !query.trim())
+            return;
+        setQueryError('');
+        setState('executing');
+        const startTime = performance.now();
+        try {
+            const result = await client.query(query);
+            const executionTime = performance.now() - startTime;
+            const parsed = parseQueryResult(result, executionTime);
+            setResults(parsed);
+            setState('results');
+        }
+        catch (err) {
+            setQueryError(err.message);
+            setState('connected');
+        }
+    };
+    const handleBackToQuery = () => {
+        setResults(null);
+        setState('connected');
     };
     // Error state
     if (state === 'error') {
@@ -76,27 +99,58 @@ const App = ({ config }) => {
     if (state === 'connecting') {
         return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, children: "QuickQuery" }), _jsxs(Text, { dimColor: true, children: [config.host, ":", config.port, "/", config.database] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "yellow", children: "Connecting..." }) })] }));
     }
+    // Executing query state
+    if (state === 'executing') {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "green", children: "Connected" }), _jsxs(Text, { dimColor: true, children: [" ", username, "@", config.host, ":", config.port, "/", config.database] })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "yellow", children: "Executing query..." }) })] }));
+    }
+    // Results state
+    if (state === 'results' && results) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "green", children: "Connected" }), _jsxs(Text, { dimColor: true, children: [" ", username, "@", config.host, ":", config.port, "/", config.database] })] }), _jsx(QueryResults, { data: results, onBack: handleBackToQuery })] }));
+    }
     // Connected - show query editor
     if (state === 'connected') {
-        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "green", children: "Connected" }), _jsxs(Text, { dimColor: true, children: [" ", username, "@", config.host, ":", config.port, "/", config.database] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Enter SQL query (press Enter to execute):" }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "> " }), _jsx(TextInput, { value: query, onChange: setQuery, onSubmit: handleQuerySubmit, language: "sql", placeholder: "SELECT * FROM ..." })] })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Ctrl+C to exit" }) })] }));
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "green", children: "Connected" }), _jsxs(Text, { dimColor: true, children: [" ", username, "@", config.host, ":", config.port, "/", config.database] })] }), queryError && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: "red", children: "Query Error" }), _jsx(Text, { color: "red", children: queryError })] })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Enter SQL query (press Enter to execute):" }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "> " }), _jsx(TextInput, { value: query, onChange: setQuery, onSubmit: handleQuerySubmit, language: "sql", placeholder: "SELECT * FROM ..." })] })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Ctrl+C to exit" }) })] }));
     }
     // Login prompts
     return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, children: "QuickQuery" }), _jsxs(Text, { dimColor: true, children: [config.host, ":", config.port, "/", config.database] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { children: "Username: " }), state === 'username' ? (_jsx(TextInput, { value: username, onChange: setUsername, onSubmit: handleUsernameSubmit, placeholder: "Enter username" })) : (_jsx(Text, { children: username }))] }), state === 'password' && (_jsxs(Box, { children: [_jsx(Text, { children: "Password: " }), _jsx(TextInput, { value: password, onChange: setPassword, onSubmit: handlePasswordSubmit, placeholder: "Enter password", mask: "*" })] }))] })] }));
 };
+// Test mode component
+const TestApp = () => {
+    const { exit } = useApp();
+    const handleBack = () => {
+        exit();
+    };
+    useInput((input, key) => {
+        if (key.ctrl && input === 'c') {
+            exit();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "yellow", children: "Test Mode" }), _jsx(Text, { dimColor: true, children: " - Displaying sample data" })] }), _jsx(QueryResults, { data: TEST_QUERY_RESULT, onBack: handleBack })] }));
+};
 // Parse CLI arguments
 const args = process.argv.slice(2);
-const databaseUrl = args[0];
-if (!databaseUrl) {
-    console.error('Usage: qq <database-url>');
-    console.error('Example: qq jdbc:postgresql://localhost:5432/postgres');
-    process.exit(1);
+// Check for --test-table flag
+if (args.includes('--test-table')) {
+    render(_jsx(TestApp, {}));
 }
-let config;
-try {
-    config = parseJdbcUrl(databaseUrl);
-}
-catch (err) {
-    console.error(err.message);
-    process.exit(1);
+else {
+    const databaseUrl = args[0];
+    if (!databaseUrl) {
+        console.error('Usage: qq <database-url>');
+        console.error('       qq --test-table');
+        console.error('');
+        console.error('Examples:');
+        console.error('  qq jdbc:postgresql://localhost:5432/postgres');
+        console.error('  qq --test-table    # Test table display with sample data');
+        process.exit(1);
+    }
+    let config;
+    try {
+        config = parseJdbcUrl(databaseUrl);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+    render(_jsx(App, { config: config }));
 }
-render(_jsx(App, { config: config }));

package/dist/testdata.d.ts

@@ -0,0 +1,2 @@
+import type { QueryResultData } from './types.js';
+export declare const TEST_QUERY_RESULT: QueryResultData;

package/dist/testdata.js

@@ -0,0 +1,266 @@
+export const TEST_QUERY_RESULT = {
+    columns: [
+        { name: 'id', dataTypeID: 23, width: 4 },
+        { name: 'name', dataTypeID: 25, width: 20 },
+        { name: 'email', dataTypeID: 25, width: 30 },
+        { name: 'age', dataTypeID: 23, width: 4 },
+        { name: 'active', dataTypeID: 16, width: 6 },
+        { name: 'balance', dataTypeID: 1700, width: 10 },
+        { name: 'created_at', dataTypeID: 1184, width: 24 },
+        { name: 'metadata', dataTypeID: 114, width: 20 },
+    ],
+    rows: [
+        {
+            id: 1,
+            name: 'Alice Johnson',
+            email: 'alice@example.com',
+            age: 28,
+            active: true,
+            balance: 1523.45,
+            created_at: new Date('2024-01-15T10:30:00Z'),
+            metadata: { role: 'admin', tier: 'gold' },
+        },
+        {
+            id: 2,
+            name: 'Bob Smith',
+            email: 'bob.smith@company.org',
+            age: 35,
+            active: true,
+            balance: 892.0,
+            created_at: new Date('2024-02-20T14:45:00Z'),
+            metadata: { role: 'user', tier: 'silver' },
+        },
+        {
+            id: 3,
+            name: 'Charlie Brown',
+            email: 'charlie.b@email.net',
+            age: 42,
+            active: false,
+            balance: 0,
+            created_at: new Date('2023-11-05T09:15:00Z'),
+            metadata: null,
+        },
+        {
+            id: 4,
+            name: 'Diana Prince',
+            email: 'diana@wonderwoman.io',
+            age: 31,
+            active: true,
+            balance: 15000.99,
+            created_at: new Date('2024-03-01T00:00:00Z'),
+            metadata: { role: 'superuser', tier: 'platinum' },
+        },
+        {
+            id: 5,
+            name: 'Edward Norton',
+            email: null,
+            age: 55,
+            active: false,
+            balance: 234.56,
+            created_at: new Date('2022-06-10T16:20:00Z'),
+            metadata: { role: 'user' },
+        },
+        {
+            id: 6,
+            name: 'Fiona Green',
+            email: 'fiona.green@startup.co',
+            age: 24,
+            active: true,
+            balance: 5678.9,
+            created_at: new Date('2024-04-12T11:00:00Z'),
+            metadata: { role: 'user', tier: 'gold' },
+        },
+        {
+            id: 7,
+            name: 'George Washington',
+            email: 'george@presidents.gov',
+            age: null,
+            active: true,
+            balance: 1776.0,
+            created_at: new Date('1776-07-04T12:00:00Z'),
+            metadata: { role: 'founder' },
+        },
+        {
+            id: 8,
+            name: 'Hannah Montana',
+            email: 'hannah@disney.com',
+            age: 19,
+            active: false,
+            balance: null,
+            created_at: new Date('2024-01-01T00:00:00Z'),
+            metadata: null,
+        },
+        {
+            id: 9,
+            name: 'Ivan Drago',
+            email: 'ivan@boxing.ru',
+            age: 38,
+            active: true,
+            balance: 999999.99,
+            created_at: new Date('2023-12-25T18:30:00Z'),
+            metadata: { role: 'champion', wins: 50 },
+        },
+        {
+            id: 10,
+            name: 'Julia Roberts',
+            email: 'julia@hollywood.com',
+            age: 56,
+            active: true,
+            balance: 50000.0,
+            created_at: new Date('2020-08-15T20:00:00Z'),
+            metadata: { role: 'vip', tier: 'diamond' },
+        },
+        {
+            id: 11,
+            name: 'Kevin Hart',
+            email: 'kevin@comedy.com',
+            age: 44,
+            active: true,
+            balance: 75000.5,
+            created_at: new Date('2021-03-20T10:00:00Z'),
+            metadata: { role: 'entertainer' },
+        },
+        {
+            id: 12,
+            name: 'Lisa Simpson',
+            email: 'lisa@springfield.edu',
+            age: 8,
+            active: true,
+            balance: 12.34,
+            created_at: new Date('2024-05-01T08:00:00Z'),
+            metadata: { role: 'student', grade: 'A+' },
+        },
+        {
+            id: 13,
+            name: 'Michael Scott',
+            email: 'michael@dundermifflin.com',
+            age: 49,
+            active: false,
+            balance: 100.0,
+            created_at: new Date('2023-09-15T09:00:00Z'),
+            metadata: { role: 'manager', branch: 'Scranton' },
+        },
+        {
+            id: 14,
+            name: 'Nancy Drew',
+            email: 'nancy@detective.org',
+            age: 18,
+            active: true,
+            balance: 567.89,
+            created_at: new Date('2024-06-01T14:00:00Z'),
+            metadata: { role: 'investigator' },
+        },
+        {
+            id: 15,
+            name: 'Oscar Martinez',
+            email: 'oscar@accounting.com',
+            age: 41,
+            active: true,
+            balance: 8901.23,
+            created_at: new Date('2022-11-30T17:00:00Z'),
+            metadata: { role: 'accountant', certified: true },
+        },
+        {
+            id: 16,
+            name: 'Pam Beesly',
+            email: 'pam@art.com',
+            age: 36,
+            active: true,
+            balance: 456.78,
+            created_at: new Date('2023-04-10T12:30:00Z'),
+            metadata: { role: 'artist' },
+        },
+        {
+            id: 17,
+            name: 'Quincy Jones',
+            email: 'quincy@music.com',
+            age: 91,
+            active: true,
+            balance: 1000000.0,
+            created_at: new Date('2019-01-01T00:00:00Z'),
+            metadata: { role: 'legend', grammys: 28 },
+        },
+        {
+            id: 18,
+            name: 'Rachel Green',
+            email: 'rachel@fashion.nyc',
+            age: 34,
+            active: false,
+            balance: 2345.67,
+            created_at: new Date('2024-02-14T19:00:00Z'),
+            metadata: { role: 'buyer' },
+        },
+        {
+            id: 19,
+            name: 'Steve Rogers',
+            email: 'cap@avengers.org',
+            age: 105,
+            active: true,
+            balance: 1945.0,
+            created_at: new Date('1945-05-08T15:00:00Z'),
+            metadata: { role: 'hero', shield: true },
+        },
+        {
+            id: 20,
+            name: 'Tina Turner',
+            email: null,
+            age: null,
+            active: false,
+            balance: null,
+            created_at: new Date('2023-05-24T00:00:00Z'),
+            metadata: null,
+        },
+        {
+            id: 21,
+            name: 'Uma Thurman',
+            email: 'uma@killbill.com',
+            age: 54,
+            active: true,
+            balance: 30000.0,
+            created_at: new Date('2024-04-01T10:00:00Z'),
+            metadata: { role: 'actress' },
+        },
+        {
+            id: 22,
+            name: 'Vin Diesel',
+            email: 'vin@fastandfurious.com',
+            age: 57,
+            active: true,
+            balance: 200000000.0,
+            created_at: new Date('2001-06-22T00:00:00Z'),
+            metadata: { role: 'family', cars: 100 },
+        },
+        {
+            id: 23,
+            name: 'Wanda Maximoff',
+            email: 'wanda@westview.com',
+            age: 29,
+            active: true,
+            balance: null,
+            created_at: new Date('2024-03-15T21:00:00Z'),
+            metadata: { role: 'witch', power: 'chaos magic' },
+        },
+        {
+            id: 24,
+            name: 'Xavier Charles',
+            email: 'professor@xmen.edu',
+            age: 67,
+            active: true,
+            balance: 5000000.0,
+            created_at: new Date('2000-07-14T00:00:00Z'),
+            metadata: { role: 'telepath', school: 'gifted' },
+        },
+        {
+            id: 25,
+            name: 'Yoda',
+            email: null,
+            age: 900,
+            active: false,
+            balance: 0,
+            created_at: new Date('1980-05-21T00:00:00Z'),
+            metadata: { role: 'master', wisdom: 'infinite' },
+        },
+    ],
+    rowCount: 25,
+    executionTime: 42.5,
+};

package/dist/types.d.ts

@@ -0,0 +1,32 @@
+import type { QueryResult } from 'pg';
+export interface ColumnInfo {
+    name: string;
+    dataTypeID: number;
+    width: number;
+}
+export interface QueryResultData {
+    columns: ColumnInfo[];
+    rows: Record<string, unknown>[];
+    rowCount: number;
+    executionTime: number;
+}
+export interface CellValue {
+    value: unknown;
+    type: 'string' | 'number' | 'boolean' | 'null' | 'date' | 'json' | 'unknown';
+}
+export declare function parseQueryResult(result: QueryResult, executionTime: number): QueryResultData;
+export declare function formatValue(value: unknown): string;
+export declare function getCellType(value: unknown): CellValue['type'];
+export declare function truncate(str: string, maxLength: number): string;
+export declare function padCell(value: string, width: number, type: CellValue['type']): string;
+/**
+ * Calculate the total width a table would take given columns.
+ * Each column takes: 1 space + content + 1 space + 1 border (│)
+ * Plus: 1 selection indicator + 1 initial border
+ */
+export declare function calculateTableWidth(columns: ColumnInfo[]): number;
+/**
+ * Fit columns to available terminal width by proportionally shrinking if needed.
+ * Returns new column array with adjusted widths.
+ */
+export declare function fitColumnsToWidth(columns: ColumnInfo[], terminalWidth: number): ColumnInfo[];

package/dist/types.js

@@ -0,0 +1,131 @@
+export function parseQueryResult(result, executionTime) {
+    const columns = result.fields.map((field) => ({
+        name: field.name,
+        dataTypeID: field.dataTypeID,
+        width: field.name.length,
+    }));
+    // Calculate column widths based on data
+    for (const row of result.rows) {
+        for (let i = 0; i < columns.length; i++) {
+            const col = columns[i];
+            const value = row[col.name];
+            const strValue = formatValue(value);
+            col.width = Math.max(col.width, strValue.length);
+        }
+    }
+    // Cap column widths at a reasonable maximum
+    const MAX_COL_WIDTH = 40;
+    for (const col of columns) {
+        col.width = Math.min(col.width, MAX_COL_WIDTH);
+    }
+    return {
+        columns,
+        rows: result.rows,
+        rowCount: result.rowCount ?? result.rows.length,
+        executionTime,
+    };
+}
+export function formatValue(value) {
+    if (value === null) {
+        return 'NULL';
+    }
+    if (value === undefined) {
+        return '';
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+export function getCellType(value) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'null';
+    if (typeof value === 'boolean')
+        return 'boolean';
+    if (typeof value === 'number')
+        return 'number';
+    if (value instanceof Date)
+        return 'date';
+    if (typeof value === 'object')
+        return 'json';
+    if (typeof value === 'string')
+        return 'string';
+    return 'unknown';
+}
+export function truncate(str, maxLength) {
+    if (str.length <= maxLength) {
+        return str;
+    }
+    return str.slice(0, maxLength - 1) + '…';
+}
+export function padCell(value, width, type) {
+    const truncated = truncate(value, width);
+    // Right-align numbers, left-align everything else
+    if (type === 'number') {
+        return truncated.padStart(width);
+    }
+    return truncated.padEnd(width);
+}
+/**
+ * Calculate the total width a table would take given columns.
+ * Each column takes: 1 space + content + 1 space + 1 border (│)
+ * Plus: 1 selection indicator + 1 initial border
+ */
+export function calculateTableWidth(columns) {
+    // Selection indicator (1) + initial border (1) + each column (width + 3 for " content │")
+    return 2 + columns.reduce((sum, col) => sum + col.width + 3, 0);
+}
+/**
+ * Fit columns to available terminal width by proportionally shrinking if needed.
+ * Returns new column array with adjusted widths.
+ */
+export function fitColumnsToWidth(columns, terminalWidth) {
+    const MIN_COL_WIDTH = 3; // Minimum readable width
+    const FIXED_OVERHEAD = 2; // Selection indicator + initial border
+    const PER_COL_OVERHEAD = 3; // " " + content + " │"
+    // Available width for actual content
+    const totalOverhead = FIXED_OVERHEAD + columns.length * PER_COL_OVERHEAD;
+    const availableContentWidth = terminalWidth - totalOverhead;
+    // Current total content width
+    const currentContentWidth = columns.reduce((sum, col) => sum + col.width, 0);
+    // If it fits, return as-is
+    if (currentContentWidth <= availableContentWidth) {
+        return columns;
+    }
+    // Need to shrink - calculate proportionally
+    const scaleFactor = availableContentWidth / currentContentWidth;
+    // First pass: scale proportionally, enforce minimum
+    let adjusted = columns.map((col) => ({
+        ...col,
+        width: Math.max(MIN_COL_WIDTH, Math.floor(col.width * scaleFactor)),
+    }));
+    // Second pass: if we're still over, trim largest columns first
+    let adjustedTotal = adjusted.reduce((sum, col) => sum + col.width, 0);
+    while (adjustedTotal > availableContentWidth && adjustedTotal > columns.length * MIN_COL_WIDTH) {
+        // Find the widest column that's above minimum
+        let maxIdx = -1;
+        let maxWidth = MIN_COL_WIDTH;
+        for (let i = 0; i < adjusted.length; i++) {
+            if (adjusted[i].width > maxWidth) {
+                maxWidth = adjusted[i].width;
+                maxIdx = i;
+            }
+        }
+        if (maxIdx === -1)
+            break; // All at minimum
+        adjusted[maxIdx] = { ...adjusted[maxIdx], width: adjusted[maxIdx].width - 1 };
+        adjustedTotal--;
+    }
+    return adjusted;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickerquery",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A terminal-based database query tool inspired by JetBrains DataGrip",
   "license": "MIT",
   "type": "module",