@grec0/memory-bank-mcp 0.1.21 → 0.1.23

package/dist/common/agentBoardSqlite.js

@@ -0,0 +1,486 @@
+/**
+ * @fileoverview SQLite-based Agent Board Implementation
+ * Replaces Markdown-based agentBoard with proper database operations.
+ * Provides project-centric task management and multi-agent coordination.
+ */
+import { databaseManager } from './database.js';
+import * as crypto from 'crypto';
+// ============================================================================
+// Agent Board SQLite Implementation
+// ============================================================================
+export class AgentBoardSqlite {
+    projectId;
+    constructor(projectId) {
+        this.projectId = projectId;
+    }
+    // ========================================================================
+    // Agent Management
+    // ========================================================================
+    /**
+     * Register a new agent for this project.
+     * Automatically deactivates any previous active agent.
+     * The MCP generates the hash suffix - client only provides base ID.
+     */
+    registerAgent(baseAgentId, sessionId) {
+        const db = databaseManager.getConnection();
+        // Generate unique agent ID with hash suffix
+        const suffix = crypto.randomUUID().slice(0, 8);
+        const fullAgentId = `${baseAgentId}-${suffix}`;
+        // Generate session ID if not provided
+        const effectiveSessionId = sessionId || crypto.randomUUID();
+        const now = new Date().toISOString();
+        return databaseManager.transaction(() => {
+            // Deactivate any currently active agents for this project
+            db.prepare(`
+                UPDATE agents 
+                SET status = 'INACTIVE', last_heartbeat = ?
+                WHERE project_id = ? AND status = 'ACTIVE'
+            `).run(now, this.projectId);
+            // Insert new agent as ACTIVE
+            db.prepare(`
+                INSERT INTO agents (id, project_id, session_id, status, focus, last_heartbeat)
+                VALUES (?, ?, ?, 'ACTIVE', '-', ?)
+            `).run(fullAgentId, this.projectId, effectiveSessionId, now);
+            // Log the registration
+            this.logMessage(fullAgentId, `Agent registered and activated`);
+            return { agentId: fullAgentId, sessionId: effectiveSessionId };
+        });
+    }
+    /**
+     * Get the currently active agent for this project
+     */
+    getActiveAgent() {
+        const db = databaseManager.getConnection();
+        const row = db.prepare(`
+            SELECT id, project_id, session_id, status, focus, last_heartbeat, created_at
+            FROM agents
+            WHERE project_id = ? AND status = 'ACTIVE'
+            ORDER BY last_heartbeat DESC
+            LIMIT 1
+        `).get(this.projectId);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            projectId: row.project_id,
+            sessionId: row.session_id,
+            status: row.status,
+            focus: row.focus,
+            lastHeartbeat: row.last_heartbeat,
+            createdAt: row.created_at
+        };
+    }
+    /**
+     * Get session ID for a specific agent
+     */
+    getSessionId(agentId) {
+        const db = databaseManager.getConnection();
+        const row = db.prepare(`
+            SELECT session_id FROM agents
+            WHERE id = ? AND project_id = ?
+        `).get(agentId, this.projectId);
+        return row?.session_id || null;
+    }
+    /**
+     * Resolve an agent ID - find the active agent matching a base ID prefix
+     */
+    resolveActiveAgentId(baseId) {
+        const db = databaseManager.getConnection();
+        // First try exact match
+        const exact = db.prepare(`
+            SELECT id FROM agents
+            WHERE id = ? AND project_id = ? AND status = 'ACTIVE'
+        `).get(baseId, this.projectId);
+        if (exact)
+            return exact.id;
+        // Try prefix match - find most recent active agent starting with baseId
+        const prefixMatch = db.prepare(`
+            SELECT id FROM agents
+            WHERE project_id = ? AND status = 'ACTIVE' AND id LIKE ?
+            ORDER BY last_heartbeat DESC
+            LIMIT 1
+        `).get(this.projectId, `${baseId}-%`);
+        return prefixMatch?.id || baseId;
+    }
+    /**
+     * Update agent status and focus
+     */
+    updateStatus(agentId, status, focus) {
+        const db = databaseManager.getConnection();
+        const now = new Date().toISOString();
+        // Resolve to actual agent ID if base ID provided
+        const resolvedId = this.resolveActiveAgentId(agentId);
+        db.prepare(`
+            UPDATE agents
+            SET status = ?, focus = ?, last_heartbeat = ?
+            WHERE id = ? AND project_id = ?
+        `).run(status, focus, now, resolvedId, this.projectId);
+    }
+    /**
+     * Update heartbeat for an agent
+     */
+    heartbeat(agentId) {
+        const db = databaseManager.getConnection();
+        const now = new Date().toISOString();
+        db.prepare(`
+            UPDATE agents
+            SET last_heartbeat = ?
+            WHERE id = ? AND project_id = ?
+        `).run(now, agentId, this.projectId);
+    }
+    /**
+     * Get all agents for this project (for session history view)
+     */
+    getAllAgents() {
+        const db = databaseManager.getConnection();
+        const rows = db.prepare(`
+            SELECT id, project_id, session_id, status, focus, last_heartbeat, created_at
+            FROM agents
+            WHERE project_id = ?
+            ORDER BY created_at DESC
+        `).all(this.projectId);
+        return rows.map(row => ({
+            id: row.id,
+            projectId: row.project_id,
+            sessionId: row.session_id,
+            status: row.status,
+            focus: row.focus,
+            lastHeartbeat: row.last_heartbeat,
+            createdAt: row.created_at
+        }));
+    }
+    // ========================================================================
+    // Task Management (Project-centric)
+    // ========================================================================
+    /**
+     * Create a task for this project
+     */
+    createTask(title, description, fromAgent) {
+        const db = databaseManager.getConnection();
+        const taskId = `TASK-${Date.now().toString().slice(-6)}`;
+        const now = new Date().toISOString();
+        db.prepare(`
+            INSERT INTO tasks (id, project_id, title, description, from_agent, status, created_at)
+            VALUES (?, ?, ?, ?, ?, 'PENDING', ?)
+        `).run(taskId, this.projectId, title, description || null, fromAgent || null, now);
+        this.logMessage(fromAgent || 'SYSTEM', `Created task ${taskId}: ${title}`);
+        return taskId;
+    }
+    /**
+     * Create an external task (cross-project delegation)
+     */
+    createExternalTask(title, fromProjectId, context) {
+        const db = databaseManager.getConnection();
+        const taskId = `EXT-${Date.now().toString().slice(-6)}`;
+        const now = new Date().toISOString();
+        db.prepare(`
+            INSERT INTO tasks (id, project_id, title, description, from_project, status, created_at)
+            VALUES (?, ?, ?, ?, ?, 'PENDING', ?)
+        `).run(taskId, this.projectId, title, context || null, fromProjectId, now);
+        this.logMessage('SYSTEM', `External task ${taskId} from ${fromProjectId}: ${title}`);
+        return taskId;
+    }
+    /**
+     * Get pending tasks for this project
+     */
+    getPendingTasks() {
+        const db = databaseManager.getConnection();
+        const rows = db.prepare(`
+            SELECT * FROM tasks
+            WHERE project_id = ? AND status IN ('PENDING', 'IN_PROGRESS')
+            ORDER BY created_at ASC
+        `).all(this.projectId);
+        return rows.map(this.mapTaskRow);
+    }
+    /**
+     * Claim a task (agent takes ownership)
+     */
+    claimTask(taskId, agentId) {
+        const db = databaseManager.getConnection();
+        const now = new Date().toISOString();
+        const result = db.prepare(`
+            UPDATE tasks
+            SET status = 'IN_PROGRESS', claimed_by = ?, claimed_at = ?
+            WHERE id = ? AND project_id = ? AND status = 'PENDING'
+        `).run(agentId, now, taskId, this.projectId);
+        if (result.changes > 0) {
+            this.logMessage(agentId, `Claimed task ${taskId}`);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Complete a task
+     */
+    completeTask(taskId, agentId) {
+        const db = databaseManager.getConnection();
+        const now = new Date().toISOString();
+        const result = db.prepare(`
+            UPDATE tasks
+            SET status = 'COMPLETED', completed_at = ?
+            WHERE id = ? AND project_id = ?
+        `).run(now, taskId, this.projectId);
+        if (result.changes > 0) {
+            this.logMessage(agentId, `Completed task ${taskId}`);
+            return true;
+        }
+        return false;
+    }
+    mapTaskRow(row) {
+        return {
+            id: row.id,
+            projectId: row.project_id,
+            title: row.title,
+            description: row.description,
+            fromProject: row.from_project,
+            fromAgent: row.from_agent,
+            status: row.status,
+            claimedBy: row.claimed_by,
+            createdAt: row.created_at,
+            claimedAt: row.claimed_at,
+            completedAt: row.completed_at
+        };
+    }
+    // ========================================================================
+    // Resource Locks
+    // ========================================================================
+    /**
+     * Claim a resource lock
+     */
+    claimResource(agentId, resource) {
+        const db = databaseManager.getConnection();
+        const now = new Date().toISOString();
+        try {
+            return databaseManager.transaction(() => {
+                // Check if already locked by someone else
+                const existing = db.prepare(`
+                    SELECT agent_id FROM locks
+                    WHERE resource = ? AND project_id = ?
+                `).get(resource, this.projectId);
+                if (existing && existing.agent_id !== agentId) {
+                    return false; // Already locked by another agent
+                }
+                // Insert or update lock
+                db.prepare(`
+                    INSERT OR REPLACE INTO locks (resource, project_id, agent_id, acquired_at)
+                    VALUES (?, ?, ?, ?)
+                `).run(resource, this.projectId, agentId, now);
+                this.logMessage(agentId, `Claimed lock on ${resource}`);
+                return true;
+            });
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Release a resource lock
+     */
+    releaseResource(agentId, resource) {
+        const db = databaseManager.getConnection();
+        db.prepare(`
+            DELETE FROM locks
+            WHERE resource = ? AND project_id = ? AND agent_id = ?
+        `).run(resource, this.projectId, agentId);
+        this.logMessage(agentId, `Released lock on ${resource}`);
+    }
+    /**
+     * Get all locks for this project
+     */
+    getLocks() {
+        const db = databaseManager.getConnection();
+        const rows = db.prepare(`
+            SELECT resource, project_id, agent_id, acquired_at
+            FROM locks
+            WHERE project_id = ?
+        `).all(this.projectId);
+        return rows.map(row => ({
+            resource: row.resource,
+            projectId: row.project_id,
+            agentId: row.agent_id,
+            acquiredAt: row.acquired_at
+        }));
+    }
+    /**
+     * Release all locks held by an agent (cleanup)
+     */
+    releaseAllLocks(agentId) {
+        const db = databaseManager.getConnection();
+        const result = db.prepare(`
+            DELETE FROM locks
+            WHERE agent_id = ? AND project_id = ?
+        `).run(agentId, this.projectId);
+        return result.changes;
+    }
+    /**
+     * Cleanup orphaned locks (locks from inactive agents)
+     */
+    cleanupOrphanedLocks() {
+        const db = databaseManager.getConnection();
+        const result = db.prepare(`
+            DELETE FROM locks
+            WHERE project_id = ? AND agent_id NOT IN (
+                SELECT id FROM agents WHERE project_id = ? AND status = 'ACTIVE'
+            )
+        `).run(this.projectId, this.projectId);
+        return result.changes;
+    }
+    // ========================================================================
+    // Session Events
+    // ========================================================================
+    /**
+     * Log a session event
+     */
+    logSessionEvent(sessionId, eventType, eventData, agentId) {
+        const db = databaseManager.getConnection();
+        const now = new Date().toISOString();
+        db.prepare(`
+            INSERT INTO session_events (project_id, session_id, agent_id, event_type, event_data, timestamp)
+            VALUES (?, ?, ?, ?, ?, ?)
+        `).run(this.projectId, sessionId, agentId || null, eventType, JSON.stringify(eventData), now);
+    }
+    /**
+     * Get session history for a specific session
+     */
+    getSessionHistory(sessionId) {
+        const db = databaseManager.getConnection();
+        const rows = db.prepare(`
+            SELECT id, project_id, session_id, agent_id, event_type, event_data, timestamp
+            FROM session_events
+            WHERE session_id = ?
+            ORDER BY timestamp ASC
+        `).all(sessionId);
+        return rows.map(row => ({
+            id: row.id,
+            projectId: row.project_id,
+            sessionId: row.session_id,
+            agentId: row.agent_id,
+            eventType: row.event_type,
+            eventData: JSON.parse(row.event_data),
+            timestamp: row.timestamp
+        }));
+    }
+    /**
+     * Get all sessions for this project (for UI display)
+     */
+    getProjectSessions() {
+        const db = databaseManager.getConnection();
+        const rows = db.prepare(`
+            SELECT 
+                session_id,
+                MAX(agent_id) as agent_id,
+                COUNT(*) as event_count,
+                MIN(timestamp) as first_event,
+                MAX(timestamp) as last_event
+            FROM session_events
+            WHERE project_id = ?
+            GROUP BY session_id
+            ORDER BY last_event DESC
+        `).all(this.projectId);
+        return rows.map(row => ({
+            sessionId: row.session_id,
+            agentId: row.agent_id,
+            eventCount: row.event_count,
+            firstEvent: row.first_event,
+            lastEvent: row.last_event
+        }));
+    }
+    // ========================================================================
+    // Messages (Agent Log)
+    // ========================================================================
+    /**
+     * Log a message
+     */
+    logMessage(agentId, message) {
+        const db = databaseManager.getConnection();
+        const now = new Date().toISOString();
+        db.prepare(`
+            INSERT INTO messages (project_id, agent_id, message, timestamp)
+            VALUES (?, ?, ?, ?)
+        `).run(this.projectId, agentId, message, now);
+    }
+    /**
+     * Get recent messages
+     */
+    getMessages(limit = 20) {
+        const db = databaseManager.getConnection();
+        const rows = db.prepare(`
+            SELECT id, project_id, agent_id, message, timestamp
+            FROM messages
+            WHERE project_id = ?
+            ORDER BY timestamp DESC
+            LIMIT ?
+        `).all(this.projectId, limit);
+        return rows.map(row => ({
+            id: row.id,
+            projectId: row.project_id,
+            agentId: row.agent_id,
+            message: row.message,
+            timestamp: row.timestamp
+        }));
+    }
+    // ========================================================================
+    // Export to Markdown (for compatibility/display)
+    // ========================================================================
+    /**
+     * Generate Markdown representation of the board (for get_board action)
+     */
+    exportToMarkdown() {
+        const agents = this.getAllAgents();
+        const tasks = this.getPendingTasks();
+        const locks = this.getLocks();
+        const messages = this.getMessages(20);
+        const lines = [
+            '# Multi-Agent Board',
+            '',
+            '## Active Agents',
+            '| Agent ID | Status | Current Focus | Session ID | Last Heartbeat |',
+            '|---|---|---|---|---|',
+            ...agents.map(a => `| ${a.id} | ${a.status} | ${a.focus} | ${a.sessionId} | ${a.lastHeartbeat} |`),
+            '',
+            '## Pending Tasks',
+            '| ID | Title | From | Status | Created At |',
+            '|---|---|---|---|---|',
+            ...tasks.map(t => `| ${t.id} | ${t.title} | ${t.fromProject || t.fromAgent || '-'} | ${t.status} | ${t.createdAt} |`),
+            '',
+            '## File Locks',
+            '| File Pattern | Claimed By | Since |',
+            '|---|---|---|',
+            ...locks.map(l => `| ${l.resource} | ${l.agentId} | ${l.acquiredAt} |`),
+            '',
+            '## Agent Messages',
+            ...messages.reverse().map(m => `- [${m.timestamp.split('T')[1]?.split('.')[0] || m.timestamp}] **${m.agentId}**: ${m.message}`),
+            ''
+        ];
+        return lines.join('\n');
+    }
+}
+// ============================================================================
+// Cleanup utilities
+// ============================================================================
+/**
+ * Cleanup stale agents (no heartbeat for specified minutes)
+ */
+export function cleanupStaleAgents(staleMinutes = 30) {
+    const db = databaseManager.getConnection();
+    const result = db.prepare(`
+        UPDATE agents
+        SET status = 'INACTIVE'
+        WHERE status = 'ACTIVE' 
+        AND datetime(last_heartbeat) < datetime('now', '-' || ? || ' minutes')
+    `).run(staleMinutes);
+    return result.changes;
+}
+/**
+ * Cleanup all orphaned locks across all projects
+ */
+export function cleanupAllOrphanedLocks() {
+    const db = databaseManager.getConnection();
+    const result = db.prepare(`
+        DELETE FROM locks
+        WHERE agent_id NOT IN (
+            SELECT id FROM agents WHERE status = 'ACTIVE'
+        )
+    `).run();
+    return result.changes;
+}

package/dist/common/database.js

@@ -0,0 +1,199 @@
+/**
+ * @fileoverview SQLite Database Manager for Memory Bank
+ * Centralized database for agent coordination, sessions, tasks, and locks.
+ * Located at ~/.memorybank/agentboard.db (same directory as global_registry.json)
+ */
+import Database from 'better-sqlite3';
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs';
+const SCHEMA_VERSION = 1;
+/**
+ * SQL Schema for Agent Board
+ */
+const SCHEMA_SQL = `
+-- Agents: All agent sessions across all projects
+-- Only one agent can be ACTIVE per project at a time
+CREATE TABLE IF NOT EXISTS agents (
+    id TEXT NOT NULL,                       -- Full agent ID with hash suffix (e.g., 'Dev-VSCode-Gemini-abc12345')
+    project_id TEXT NOT NULL,               -- Project this agent is working on
+    session_id TEXT NOT NULL,               -- UUID for this session
+    status TEXT NOT NULL DEFAULT 'ACTIVE',  -- ACTIVE, INACTIVE
+    focus TEXT DEFAULT '-',                 -- Current task/file being worked on
+    last_heartbeat TEXT NOT NULL,           -- ISO timestamp of last activity
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (id, project_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_agents_project ON agents(project_id);
+CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(project_id, status);
+CREATE INDEX IF NOT EXISTS idx_agents_session ON agents(session_id);
+
+-- Tasks: Project-centric tasks (not assigned to specific agents)
+-- The active agent of a project processes its pending tasks
+CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,                    -- e.g., 'TASK-123456'
+    project_id TEXT NOT NULL,               -- Target project to handle this task
+    title TEXT NOT NULL,
+    description TEXT,                       -- Extended task description
+    from_project TEXT,                      -- Source project (for cross-project delegation)
+    from_agent TEXT,                        -- Agent that created the task
+    status TEXT NOT NULL DEFAULT 'PENDING', -- PENDING, IN_PROGRESS, COMPLETED, CANCELLED
+    claimed_by TEXT,                        -- Agent ID that claimed the task
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    claimed_at TEXT,
+    completed_at TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(project_id, status);
+CREATE INDEX IF NOT EXISTS idx_tasks_from ON tasks(from_project);
+
+-- Locks: Resource/file locks held by agents
+CREATE TABLE IF NOT EXISTS locks (
+    resource TEXT NOT NULL,                 -- Resource pattern (e.g., 'src/auth/')
+    project_id TEXT NOT NULL,               -- Project scope
+    agent_id TEXT NOT NULL,                 -- Agent holding the lock
+    acquired_at TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (resource, project_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_locks_agent ON locks(agent_id);
+CREATE INDEX IF NOT EXISTS idx_locks_project ON locks(project_id);
+
+-- Session Events: All actions performed during agent sessions
+-- Replaces JSONL files for better querying
+CREATE TABLE IF NOT EXISTS session_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    project_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    agent_id TEXT,                          -- Agent that performed the action
+    event_type TEXT NOT NULL,               -- search, read_doc, read_file, index, decision, write_file, etc.
+    event_data TEXT NOT NULL,               -- JSON blob with event details
+    timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_session ON session_events(session_id);
+CREATE INDEX IF NOT EXISTS idx_events_project ON session_events(project_id);
+CREATE INDEX IF NOT EXISTS idx_events_type ON session_events(event_type);
+CREATE INDEX IF NOT EXISTS idx_events_time ON session_events(timestamp);
+
+-- Messages: Agent communication log
+CREATE TABLE IF NOT EXISTS messages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    project_id TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    message TEXT NOT NULL,
+    timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_project ON messages(project_id);
+CREATE INDEX IF NOT EXISTS idx_messages_time ON messages(timestamp);
+
+-- Schema versioning for future migrations
+CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+`;
+/**
+ * Database Manager Singleton
+ * Manages a single SQLite connection for the entire MCP server
+ */
+class DatabaseManager {
+    static instance;
+    db = null;
+    dbPath;
+    constructor() {
+        // Same directory as global_registry.json
+        this.dbPath = path.join(os.homedir(), '.memorybank', 'agentboard.db');
+    }
+    static getInstance() {
+        if (!DatabaseManager.instance) {
+            DatabaseManager.instance = new DatabaseManager();
+        }
+        return DatabaseManager.instance;
+    }
+    /**
+     * Get or create the database connection
+     */
+    getConnection() {
+        if (this.db) {
+            return this.db;
+        }
+        // Ensure directory exists
+        const dir = path.dirname(this.dbPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Open database with WAL mode for better concurrency
+        this.db = new Database(this.dbPath, {
+            timeout: 5000, // Wait up to 5s for locks
+        });
+        // Enable WAL mode for concurrent reads during writes
+        this.db.pragma('journal_mode = WAL');
+        // Foreign keys enforcement
+        this.db.pragma('foreign_keys = ON');
+        // Initialize schema
+        this.initializeSchema();
+        console.error(`[Database] Connected to ${this.dbPath}`);
+        return this.db;
+    }
+    /**
+     * Initialize database schema
+     */
+    initializeSchema() {
+        if (!this.db)
+            return;
+        // Check current schema version
+        let currentVersion = 0;
+        try {
+            const row = this.db.prepare('SELECT MAX(version) as version FROM schema_version').get();
+            currentVersion = row?.version || 0;
+        }
+        catch {
+            // Table doesn't exist yet, version is 0
+        }
+        if (currentVersion < SCHEMA_VERSION) {
+            console.error(`[Database] Migrating schema from v${currentVersion} to v${SCHEMA_VERSION}`);
+            // Run schema creation (IF NOT EXISTS makes it safe)
+            this.db.exec(SCHEMA_SQL);
+            // Record schema version
+            if (currentVersion === 0) {
+                this.db.prepare('INSERT OR REPLACE INTO schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
+            }
+            console.error(`[Database] Schema initialized at v${SCHEMA_VERSION}`);
+        }
+    }
+    /**
+     * Close database connection
+     */
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            console.error('[Database] Connection closed');
+        }
+    }
+    /**
+     * Get the database file path
+     */
+    getDbPath() {
+        return this.dbPath;
+    }
+    /**
+     * Check if database file exists
+     */
+    exists() {
+        return fs.existsSync(this.dbPath);
+    }
+    /**
+     * Run a transaction with automatic rollback on error
+     */
+    transaction(fn) {
+        const db = this.getConnection();
+        return db.transaction(fn)();
+    }
+}
+// Export singleton instance
+export const databaseManager = DatabaseManager.getInstance();