@semics-tech/mongolite 1.1.0 → 1.3.0

package/dist/cjs/adapters/node-sqlite.js

@@ -1,7 +1,19 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeSqliteAdapter = void 0;
+exports.sharedConnectionCount = sharedConnectionCount;
 const node_sqlite_1 = require("node:sqlite");
+const node_path_1 = __importDefault(require("node:path"));
+const connection_registry_js_1 = require("../utils/connection-registry.js");
+/** Shared `node:sqlite` handles for this process, keyed by connection identity. */
+const sharedConnections = new connection_registry_js_1.ConnectionRegistry();
+/** Exposed for tests and diagnostics. */
+function sharedConnectionCount() {
+    return sharedConnections.size;
+}
 /**
  * Database adapter backed by Node.js's built-in `node:sqlite` module — no native
  * addon, no prebuilt binary, no `node-gyp`. Requires Node.js 22.5.0+ (the module
@@ -38,18 +50,34 @@ class NodeSqliteAdapter {
     constructor(dbPathOrOptions) {
         this.db = null;
         this.openPromise = null;
+        let shared;
         if (typeof dbPathOrOptions === 'string') {
             this.filePath = dbPathOrOptions;
             this.verbose = false;
             this.readOnly = false;
-            this.WAL = false;
+            this.WAL = true;
+            this.busyTimeout = connection_registry_js_1.DEFAULT_BUSY_TIMEOUT_MS;
+            shared = false;
         }
         else {
             this.filePath = dbPathOrOptions.filePath;
             this.verbose = dbPathOrOptions.verbose || false;
             this.readOnly = dbPathOrOptions.readOnly || false;
-            this.WAL = dbPathOrOptions.WAL || true;
-        }
+            this.WAL = dbPathOrOptions.WAL ?? true;
+            this.busyTimeout = dbPathOrOptions.busyTimeout ?? connection_registry_js_1.DEFAULT_BUSY_TIMEOUT_MS;
+            shared = dbPathOrOptions.shared ?? false;
+        }
+        this.shareKey =
+            shared && (0, connection_registry_js_1.isShareablePath)(this.filePath)
+                ? (0, connection_registry_js_1.buildConnectionKey)({
+                    backend: 'node:sqlite',
+                    filePath: node_path_1.default.resolve(this.filePath),
+                    readOnly: this.readOnly,
+                    WAL: this.WAL,
+                    busyTimeout: this.busyTimeout,
+                    verbose: this.verbose,
+                })
+                : null;
     }
     /**
      * Opens the database connection if it's not already open.
@@ -63,39 +91,52 @@ class NodeSqliteAdapter {
         }
         this.openPromise = new Promise((resolve, reject) => {
             try {
-                this.db = new node_sqlite_1.DatabaseSync(this.filePath, { readOnly: this.readOnly });
-                if (this.WAL && !this.readOnly) {
-                    this.db.exec('PRAGMA journal_mode = WAL');
-                }
-                // Register regexp UDF for $regex operator support.
-                // WARNING: Patterns are compiled via JavaScript RegExp. User-supplied patterns that are
-                // not validated for catastrophic backtracking (ReDoS) could block the event loop.
-                // Avoid using untrusted/unvalidated patterns with $regex in security-sensitive contexts.
-                this.db.function('regexp', { deterministic: true }, (pattern, value) => {
-                    if (typeof pattern !== 'string' || value === null || value === undefined)
-                        return 0;
-                    try {
-                        return new RegExp(pattern).test(String(value)) ? 1 : 0;
-                    }
-                    catch {
-                        return 0;
+                // Only runs on a genuinely new connection — when sharing, an existing
+                // handle already has its pragmas and UDFs applied.
+                const openConnection = () => {
+                    const db = new node_sqlite_1.DatabaseSync(this.filePath, { readOnly: this.readOnly });
+                    if (this.WAL && !this.readOnly) {
+                        db.exec('PRAGMA journal_mode = WAL');
                     }
-                });
-                // Register regexp_flags UDF for $regex with $options support
-                this.db.function('regexp_flags', { deterministic: true }, (pattern, flags, value) => {
-                    if (typeof pattern !== 'string' || value === null || value === undefined)
-                        return 0;
-                    try {
-                        const f = typeof flags === 'string' ? flags : '';
-                        return new RegExp(pattern, f).test(String(value)) ? 1 : 0;
+                    // Wait rather than immediately throwing SQLITE_BUSY when another
+                    // connection (often another process) holds a lock.
+                    if (this.busyTimeout > 0) {
+                        db.exec(`PRAGMA busy_timeout = ${this.busyTimeout}`);
                     }
-                    catch {
-                        return 0;
+                    // Register regexp UDF for $regex operator support.
+                    // WARNING: Patterns are compiled via JavaScript RegExp. User-supplied patterns that are
+                    // not validated for catastrophic backtracking (ReDoS) could block the event loop.
+                    // Avoid using untrusted/unvalidated patterns with $regex in security-sensitive contexts.
+                    db.function('regexp', { deterministic: true }, (pattern, value) => {
+                        if (typeof pattern !== 'string' || value === null || value === undefined)
+                            return 0;
+                        try {
+                            return new RegExp(pattern).test(String(value)) ? 1 : 0;
+                        }
+                        catch {
+                            return 0;
+                        }
+                    });
+                    // Register regexp_flags UDF for $regex with $options support
+                    db.function('regexp_flags', { deterministic: true }, (pattern, flags, value) => {
+                        if (typeof pattern !== 'string' || value === null || value === undefined)
+                            return 0;
+                        try {
+                            const f = typeof flags === 'string' ? flags : '';
+                            return new RegExp(pattern, f).test(String(value)) ? 1 : 0;
+                        }
+                        catch {
+                            return 0;
+                        }
+                    });
+                    if (this.verbose) {
+                        console.log(`SQLite database opened (node:sqlite): ${this.filePath}`);
                     }
-                });
-                if (this.verbose) {
-                    console.log(`SQLite database opened (node:sqlite): ${this.filePath}`);
-                }
+                    return db;
+                };
+                this.db = this.shareKey
+                    ? sharedConnections.acquire(this.shareKey, openConnection)
+                    : openConnection();
                 resolve();
             }
             catch (err) {
@@ -169,9 +210,17 @@ class NodeSqliteAdapter {
         }
         if (this.db) {
             try {
-                this.db.close();
+                // When shared, only the last holder actually closes the handle.
+                const isLastHolder = this.shareKey
+                    ? sharedConnections.release(this.shareKey, this.db)
+                    : true;
+                if (isLastHolder) {
+                    this.db.close();
+                }
                 if (this.verbose) {
-                    console.log(`SQLite database closed (node:sqlite): ${this.filePath}`);
+                    console.log(isLastHolder
+                        ? `SQLite database closed (node:sqlite): ${this.filePath}`
+                        : `SQLite database released (still in use): ${this.filePath}`);
                 }
             }
             catch (err) {

package/dist/cjs/bin/mongolite-debug.js

@@ -1,152 +1,9 @@
 #!/usr/bin/env node
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const query_debugger_js_1 = require("../debugger/query-debugger.js");
-const path_1 = __importDefault(require("path"));
-// CLI argument parsing
-function parseArgs() {
-    const args = process.argv.slice(2);
-    const options = {};
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--verbose' || arg === '-v') {
-            options.verbose = true;
-        }
-        else if (arg === '--collection' || arg === '-c') {
-            options.collection = args[++i];
-        }
-        else if (arg === '--database' || arg === '-d') {
-            options.database = args[++i];
-        }
-        else if (arg === '--help' || arg === '-h') {
-            options.help = true;
-        }
-    }
-    return options;
-}
-function showHelp() {
-    console.log('MongoLite Query Debugger');
-    console.log('');
-    console.log('Interactive debugging tool for MongoLite queries.');
-    console.log('');
-    console.log('Usage: npx mongolite-debug [options]');
-    console.log('');
-    console.log('Options:');
-    console.log('  -d, --database <path>     Database file path (default: ./mongolite.db)');
-    console.log('  -c, --collection <name>   Initial collection to use');
-    console.log('  -v, --verbose             Enable verbose output');
-    console.log('  -h, --help                Show this help');
-    console.log('');
-    console.log('Interactive Commands:');
-    console.log('  .help                     Show available commands');
-    console.log('  .collections              List all collections');
-    console.log('  .use <collection>         Select a collection to work with');
-    console.log('  .find <filter>            Convert find filter to SQL and execute');
-    console.log('  .sql <query>              Execute raw SQL query');
-    console.log('  .last                     Show last generated SQL');
-    console.log('  .sample [count]           Show sample documents from current collection');
-    console.log('  .exit                     Exit the debugger');
-    console.log('');
-    console.log('Examples:');
-    console.log('  npx mongolite-debug -d ./myapp.db -c users');
-    console.log('  npx mongolite-debug --verbose');
-    console.log('');
-    console.log('  # Inside the debugger:');
-    console.log('  .use users');
-    console.log('  .find {"age": {"$gt": 25}}');
-    console.log('  .sql SELECT * FROM users WHERE json_extract(data, "$.age") > 25');
-    console.log('');
-}
-async function main() {
-    const options = parseArgs();
-    if (options.help) {
-        showHelp();
-        process.exit(0);
-    }
-    // Set default database path if not provided
-    if (!options.database) {
-        // Look for common database files in the current directory
-        const cwd = process.cwd();
-        const commonNames = [
-            'mongolite.db',
-            'mongolite.sqlite',
-            'database.db',
-            'database.sqlite',
-            'app.db',
-            'app.sqlite',
-        ];
-        // Check if any common database files exist
-        const { existsSync } = await Promise.resolve().then(() => __importStar(require('fs')));
-        let foundDb = false;
-        for (const name of commonNames) {
-            const dbPath = path_1.default.join(cwd, name);
-            if (existsSync(dbPath)) {
-                options.database = dbPath;
-                foundDb = true;
-                break;
-            }
-        }
-        if (!foundDb) {
-            options.database = path_1.default.join(cwd, 'mongolite.db');
-        }
-    }
-    console.log('🔍 MongoLite Query Debugger (npx version)');
-    console.log(`📁 Database: ${options.database}`);
-    if (options.collection) {
-        console.log(`📋 Initial collection: ${options.collection}`);
-    }
-    console.log('');
-    try {
-        const queryDebugger = new query_debugger_js_1.QueryDebugger(options);
-        await queryDebugger.start();
-    }
-    catch (error) {
-        console.error('Fatal error:', error instanceof Error ? error.message : error);
-        if (error instanceof Error && error.message.includes('SQLITE_CANTOPEN')) {
-            console.error('');
-            console.error('💡 Tip: Make sure the database file exists or specify a different path with -d');
-            console.error('   Example: npx mongolite-debug -d ./path/to/your/database.db');
-        }
-        process.exit(1);
-    }
-}
-main().catch((error) => {
-    console.error('Unexpected error:', error);
-    process.exit(1);
-});
+/**
+ * `mongolite-debug` is kept as an alias of `mongolite` so existing scripts and
+ * muscle memory keep working. It runs the same guided explorer; pass `--repl`
+ * for the original command-driven debugger (`.use`, `.find`, `.sql`, …).
+ */
+require("./mongolite.js");

package/dist/cjs/bin/mongolite.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+/**
+ * `mongolite` — the guided explorer for MongoLite databases.
+ *
+ * Running it with no arguments is the intended path: it finds your database
+ * files, lists the collections it finds inside, and walks you through a query.
+ * Flags are shortcuts for people who already know where they are going, and
+ * `--repl` drops into the older command-driven debugger.
+ */
+const explorer_js_1 = require("../cli/explorer.js");
+const query_debugger_js_1 = require("../debugger/query-debugger.js");
+const ui_js_1 = require("../cli/ui.js");
+function parseArgs(argv) {
+    const options = { verbose: false, help: false, version: false, repl: false };
+    const positional = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        switch (arg) {
+            case '--database':
+            case '-d':
+                options.database = argv[++index];
+                break;
+            case '--collection':
+            case '-c':
+                options.collection = argv[++index];
+                break;
+            case '--verbose':
+            case '-v':
+                options.verbose = true;
+                break;
+            case '--repl':
+            case '--expert':
+                options.repl = true;
+                break;
+            case '--sample':
+                options.sampleSize = Number(argv[++index]);
+                break;
+            case '--page-size':
+                options.pageSize = Number(argv[++index]);
+                break;
+            case '--help':
+            case '-h':
+                options.help = true;
+                break;
+            case '--version':
+            case '-V':
+                options.version = true;
+                break;
+            default:
+                if (arg.startsWith('-')) {
+                    throw new Error(`Unknown option: ${arg}`);
+                }
+                positional.push(arg);
+                break;
+        }
+    }
+    // `mongolite ./app.db users` is the shape people try first, so support it.
+    if (!options.database && positional[0])
+        options.database = positional[0];
+    if (!options.collection && positional[1])
+        options.collection = positional[1];
+    return options;
+}
+function showHelp() {
+    const lines = [
+        `${ui_js_1.style.bold('mongolite')} — explore a MongoLite (SQLite-backed) database`,
+        '',
+        ui_js_1.style.bold('Usage'),
+        '  npx mongolite                      Start the guided explorer',
+        '  npx mongolite ./app.db             Open a specific database',
+        '  npx mongolite ./app.db users       Open a specific collection',
+        '',
+        ui_js_1.style.bold('Options'),
+        '  -d, --database <path>   Database file to open (otherwise you get a list to pick from)',
+        '  -c, --collection <name> Collection to start in',
+        '      --sample <n>        Documents to sample when inferring fields (default 200)',
+        '      --page-size <n>     Results shown per page (default 20)',
+        '      --repl              Use the older command-driven debugger instead',
+        '  -v, --verbose           Log the SQL being built',
+        '  -h, --help              Show this help',
+        '  -V, --version           Show the version',
+        '',
+        ui_js_1.style.bold('In the explorer'),
+        '  ↑/↓ move · type to filter the list · enter to choose · esc to go back · Ctrl+C to quit',
+        '',
+        'No MongoDB knowledge is needed: pick a field, pick a condition in plain English,',
+        'and the filter it builds is printed so you can learn the syntax as you go.',
+        'If you already know it, "Write a MongoDB filter yourself" and "Run raw SQL" are',
+        'under Advanced.',
+        '',
+    ];
+    process.stdout.write(`${lines.join('\n')}\n`);
+}
+/**
+ * Find the package version by walking up from the running script.
+ * Deliberately avoids `import.meta` and `__dirname` so the same source compiles
+ * for both the ESM and CommonJS builds.
+ */
+async function showVersion() {
+    const { readFileSync, existsSync } = await Promise.resolve().then(() => __importStar(require('node:fs')));
+    const { dirname, join, parse } = await Promise.resolve().then(() => __importStar(require('node:path')));
+    let dir = dirname(process.argv[1] ?? process.cwd());
+    const { root } = parse(dir);
+    while (dir && dir !== root) {
+        const candidate = join(dir, 'package.json');
+        if (existsSync(candidate)) {
+            try {
+                const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
+                if (pkg.version) {
+                    process.stdout.write(`${pkg.version}\n`);
+                    return;
+                }
+            }
+            catch {
+                // Unreadable package.json - keep walking up.
+            }
+        }
+        dir = dirname(dir);
+    }
+    process.stdout.write('unknown\n');
+}
+async function main() {
+    let options;
+    try {
+        options = parseArgs(process.argv.slice(2));
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.stderr.write('Run with --help to see the available options.\n');
+        process.exit(1);
+        return;
+    }
+    if (options.help) {
+        showHelp();
+        return;
+    }
+    if (options.version) {
+        await showVersion();
+        return;
+    }
+    if (options.repl) {
+        const queryDebugger = new query_debugger_js_1.QueryDebugger({
+            database: options.database,
+            collection: options.collection,
+            verbose: options.verbose,
+        });
+        await queryDebugger.start();
+        return;
+    }
+    const explorer = new explorer_js_1.Explorer({
+        database: options.database,
+        collection: options.collection,
+        verbose: options.verbose,
+        sampleSize: Number.isFinite(options.sampleSize) ? options.sampleSize : undefined,
+        pageSize: Number.isFinite(options.pageSize) ? options.pageSize : undefined,
+    });
+    await explorer.run();
+}
+main()
+    .then(() => {
+    (0, ui_js_1.closePrompts)();
+    process.exit(0);
+})
+    .catch((error) => {
+    const text = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`\n✖ ${text}\n`);
+    if (text.includes('SQLITE_CANTOPEN') || text.includes('unable to open')) {
+        process.stderr.write('  The file may not exist, or may not be readable.\n');
+    }
+    process.exit(1);
+});

package/dist/cjs/cli/discover.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDatabaseFiles = findDatabaseFiles;
+exports.formatBytes = formatBytes;
+exports.formatRelativeTime = formatRelativeTime;
+exports.listCollectionInfo = listCollectionInfo;
+exports.resolveDatabasePath = resolveDatabasePath;
+exports.databaseExists = databaseExists;
+/**
+ * Finding things for the user so they do not have to type paths or remember
+ * collection names: SQLite files on disk, and MongoLite-shaped tables inside
+ * a database.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const DB_EXTENSIONS = ['.db', '.sqlite', '.sqlite3', '.db3'];
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    '.cache',
+    'vendor',
+    '.venv',
+    'venv',
+    '__pycache__',
+]);
+/**
+ * Walk `root` looking for SQLite-looking files, skipping the usual noisy
+ * directories. Results are newest-first, since the file you just wrote is
+ * almost always the one you want.
+ */
+function findDatabaseFiles(root = process.cwd(), options = {}) {
+    const maxDepth = options.depth ?? 2;
+    const limit = options.limit ?? 50;
+    const found = [];
+    const walk = (dir, depth) => {
+        if (found.length >= limit || depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // Unreadable directory - nothing useful to say about it.
+        }
+        for (const entry of entries) {
+            if (found.length >= limit)
+                return;
+            const full = node_path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name) || entry.name.startsWith('.'))
+                    continue;
+                walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (!DB_EXTENSIONS.includes(node_path_1.default.extname(entry.name).toLowerCase()))
+                continue;
+            // WAL/SHM siblings are not databases you can open directly.
+            if (/-(wal|shm)$/.test(entry.name))
+                continue;
+            try {
+                const stats = (0, node_fs_1.statSync)(full);
+                found.push({
+                    path: full,
+                    relativePath: node_path_1.default.relative(root, full) || entry.name,
+                    sizeBytes: stats.size,
+                    modified: stats.mtime,
+                });
+            }
+            catch {
+                // File vanished between readdir and stat - ignore.
+            }
+        }
+    };
+    walk(root, 0);
+    found.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    return found;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ['KB', 'MB', 'GB', 'TB'];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value >= 10 ? Math.round(value) : value.toFixed(1)} ${units[unit]}`;
+}
+function formatRelativeTime(date, now = new Date()) {
+    const seconds = Math.max(0, Math.round((now.getTime() - date.getTime()) / 1000));
+    if (seconds < 60)
+        return 'just now';
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.round(hours / 24);
+    if (days < 30)
+        return `${days}d ago`;
+    return date.toISOString().slice(0, 10);
+}
+/**
+ * List the tables in the database, flagging which ones look like MongoLite
+ * collections (an `_id` column plus a `data` column). Foreign tables are still
+ * reported so a user pointed at the wrong file gets a useful message rather
+ * than an empty list.
+ */
+async function listCollectionInfo(db) {
+    const tables = await db.all(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);
+    const infos = [];
+    for (const { name } of tables) {
+        let isMongoLite = false;
+        try {
+            const columns = await db.all(`PRAGMA table_info("${name}")`);
+            const columnNames = new Set(columns.map((column) => column.name));
+            isMongoLite = columnNames.has('_id') && columnNames.has('data');
+        }
+        catch {
+            isMongoLite = false;
+        }
+        let count = 0;
+        try {
+            const row = await db.get(`SELECT COUNT(*) as count FROM "${name}"`);
+            count = row?.count ?? 0;
+        }
+        catch {
+            count = 0;
+        }
+        infos.push({ name, count, isMongoLite });
+    }
+    return infos;
+}
+/** Resolve a user-supplied database path, allowing `:memory:` and `~` shorthand. */
+function resolveDatabasePath(input) {
+    if (input === ':memory:')
+        return input;
+    const expanded = input.startsWith('~')
+        ? node_path_1.default.join(process.env.HOME ?? '', input.slice(1))
+        : input;
+    return node_path_1.default.resolve(expanded);
+}
+function databaseExists(dbPath) {
+    return dbPath === ':memory:' || (0, node_fs_1.existsSync)(dbPath);
+}