@gotza02/smartagent 1.2.0

package/dist/core/database.js

@@ -0,0 +1,751 @@
+/**
+ * Database Manager
+ * SQLite/libSQL database operations for context persistence
+ */
+import { createClient } from "@libsql/client";
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync, existsSync } from "fs";
+import { randomUUID } from "crypto";
+import { logger } from "../utils/logger.js";
+const SWARM_DIR = join(homedir(), ".swarm-mcp-enterprise");
+const DB_PATH = `file:${join(SWARM_DIR, "swarm.db")}`;
+/**
+ * Database Manager
+ * Handles all database operations
+ */
+export class DatabaseManager {
+    client = null;
+    initialized = false;
+    /**
+     * Initialize database connection and schema
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        // Create directory if not exists
+        if (!existsSync(SWARM_DIR)) {
+            mkdirSync(SWARM_DIR, { recursive: true });
+        }
+        // Create client
+        this.client = createClient({ url: DB_PATH });
+        // Create tables
+        await this.createSchema();
+        this.initialized = true;
+        // logger.info("Database initialized", { path: DB_PATH });
+    }
+    /**
+     * Create database schema
+     */
+    async createSchema() {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        // Agents table
+        await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        name TEXT NOT NULL,
+        mode TEXT DEFAULT 'plan',
+        status TEXT DEFAULT 'idle',
+        current_task TEXT,
+        capabilities TEXT,
+        metadata TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        last_active_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        health_check_at TEXT
+      )
+    `);
+        // Tasks table
+        await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        description TEXT NOT NULL,
+        context TEXT,
+        status TEXT DEFAULT 'pending',
+        priority INTEGER DEFAULT 5,
+        result TEXT,
+        error TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        started_at TEXT,
+        completed_at TEXT,
+        timeout INTEGER DEFAULT 60,
+        FOREIGN KEY (agent_id) REFERENCES agents(id)
+      )
+    `);
+        // Thought chains table
+        await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS thought_chains (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        task_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        thoughts TEXT,
+        branches TEXT,
+        current_step INTEGER DEFAULT 0,
+        status TEXT DEFAULT 'active',
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (agent_id) REFERENCES agents(id),
+        FOREIGN KEY (task_id) REFERENCES tasks(id)
+      )
+    `);
+        // Contexts table
+        await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS contexts (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        messages TEXT,
+        artifacts TEXT,
+        checkpoints TEXT,
+        summary TEXT,
+        token_count INTEGER DEFAULT 0,
+        max_tokens INTEGER DEFAULT 4000,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (agent_id) REFERENCES agents(id)
+      )
+    `);
+        // Handoffs table
+        await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS handoffs (
+        id TEXT PRIMARY KEY,
+        from_agent_id TEXT NOT NULL,
+        to_agent_id TEXT NOT NULL,
+        task_id TEXT NOT NULL,
+        context_snapshot TEXT,
+        notes TEXT,
+        timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (from_agent_id) REFERENCES agents(id),
+        FOREIGN KEY (to_agent_id) REFERENCES agents(id),
+        FOREIGN KEY (task_id) REFERENCES tasks(id)
+      )
+    `);
+        // Checkpoints table
+        await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS checkpoints (
+        id TEXT PRIMARY KEY,
+        context_id TEXT NOT NULL,
+        sequence INTEGER NOT NULL,
+        messages TEXT,
+        artifacts TEXT,
+        thought_chain_id TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (context_id) REFERENCES contexts(id),
+        FOREIGN KEY (thought_chain_id) REFERENCES thought_chains(id)
+      )
+    `);
+        // Audit logs table
+        await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS audit_logs (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
+        level TEXT NOT NULL,
+        category TEXT NOT NULL,
+        agent_id TEXT,
+        task_id TEXT,
+        action TEXT NOT NULL,
+        details TEXT,
+        ip TEXT,
+        user_agent TEXT
+      )
+    `);
+        // Parallel executions table
+        await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS parallel_executions (
+        id TEXT PRIMARY KEY,
+        batch_id TEXT NOT NULL,
+        tasks TEXT,
+        max_concurrency INTEGER DEFAULT 5,
+        status TEXT DEFAULT 'pending',
+        results TEXT,
+        aggregated_report TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        completed_at TEXT
+      )
+    `);
+        // Create indexes
+        await this.client.execute(`CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status)`);
+        await this.client.execute(`CREATE INDEX IF NOT EXISTS idx_agents_type ON agents(type)`);
+        await this.client.execute(`CREATE INDEX IF NOT EXISTS idx_tasks_agent_id ON tasks(agent_id)`);
+        await this.client.execute(`CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)`);
+        await this.client.execute(`CREATE INDEX IF NOT EXISTS idx_thought_chains_agent ON thought_chains(agent_id)`);
+        await this.client.execute(`CREATE INDEX IF NOT EXISTS idx_contexts_agent ON contexts(agent_id)`);
+        await this.client.execute(`CREATE INDEX IF NOT EXISTS idx_audit_timestamp ON audit_logs(timestamp)`);
+    }
+    // ============================================
+    // Agent Operations
+    // ============================================
+    async saveAgent(agent) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        await this.client.execute({
+            sql: `
+        INSERT OR REPLACE INTO agents 
+        (id, type, name, mode, status, current_task, capabilities, metadata, created_at, last_active_at, health_check_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+            args: [
+                agent.id,
+                agent.type,
+                agent.name,
+                agent.mode,
+                agent.status,
+                agent.currentTask || null,
+                JSON.stringify(agent.capabilities),
+                JSON.stringify(agent.metadata),
+                agent.createdAt,
+                agent.lastActiveAt,
+                agent.healthCheckAt || null,
+            ],
+        });
+    }
+    async getAgent(agentId) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "SELECT * FROM agents WHERE id = ?",
+            args: [agentId],
+        });
+        if (result.rows.length === 0)
+            return null;
+        const row = result.rows[0];
+        return this.rowToAgent(row);
+    }
+    async getAllAgents() {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute("SELECT * FROM agents");
+        return result.rows.map((row) => this.rowToAgent(row));
+    }
+    async getAgentsByType(type) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "SELECT * FROM agents WHERE type = ?",
+            args: [type],
+        });
+        return result.rows.map((row) => this.rowToAgent(row));
+    }
+    async getAgentsByStatus(status) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "SELECT * FROM agents WHERE status = ?",
+            args: [status],
+        });
+        return result.rows.map((row) => this.rowToAgent(row));
+    }
+    async deleteAgent(agentId) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "DELETE FROM agents WHERE id = ?",
+            args: [agentId],
+        });
+        return result.rowsAffected > 0;
+    }
+    // ============================================
+    // Task Operations
+    // ============================================
+    async saveTask(task) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        await this.client.execute({
+            sql: `
+        INSERT OR REPLACE INTO tasks 
+        (id, agent_id, type, description, context, status, priority, result, error, created_at, started_at, completed_at, timeout)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+            args: [
+                task.id,
+                task.agentId,
+                task.type,
+                task.description,
+                JSON.stringify(task.context),
+                task.status,
+                task.priority,
+                task.result ? JSON.stringify(task.result) : null,
+                task.error || null,
+                task.createdAt,
+                task.startedAt || null,
+                task.completedAt || null,
+                task.timeout,
+            ],
+        });
+    }
+    async getTask(taskId) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "SELECT * FROM tasks WHERE id = ?",
+            args: [taskId],
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.rowToTask(result.rows[0]);
+    }
+    async getTasksByAgent(agentId) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "SELECT * FROM tasks WHERE agent_id = ? ORDER BY created_at DESC",
+            args: [agentId],
+        });
+        return result.rows.map((row) => this.rowToTask(row));
+    }
+    async getTasksByStatus(status) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "SELECT * FROM tasks WHERE status = ?",
+            args: [status],
+        });
+        return result.rows.map((row) => this.rowToTask(row));
+    }
+    // ============================================
+    // Context Operations
+    // ============================================
+    async saveContext(context) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        await this.client.execute({
+            sql: `
+        INSERT OR REPLACE INTO contexts 
+        (id, agent_id, messages, artifacts, checkpoints, summary, token_count, max_tokens, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+            args: [
+                context.id,
+                context.agentId,
+                JSON.stringify(context.messages),
+                JSON.stringify(context.artifacts),
+                JSON.stringify(context.checkpoints),
+                context.summary || null,
+                context.tokenCount,
+                context.maxTokens,
+                context.createdAt,
+                context.updatedAt,
+            ],
+        });
+    }
+    async getContext(contextId) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "SELECT * FROM contexts WHERE id = ?",
+            args: [contextId],
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.rowToContext(result.rows[0]);
+    }
+    async getContextByAgent(agentId) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "SELECT * FROM contexts WHERE agent_id = ? ORDER BY updated_at DESC LIMIT 1",
+            args: [agentId],
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.rowToContext(result.rows[0]);
+    }
+    // ============================================
+    // Checkpoint Operations
+    // ============================================
+    async saveCheckpoint(checkpoint) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        await this.client.execute({
+            sql: `
+        INSERT OR REPLACE INTO checkpoints 
+        (id, context_id, sequence, messages, artifacts, thought_chain_id, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `,
+            args: [
+                checkpoint.id,
+                checkpoint.contextId,
+                checkpoint.sequence,
+                JSON.stringify(checkpoint.messages),
+                JSON.stringify(checkpoint.artifacts),
+                checkpoint.thoughtChainId || null,
+                checkpoint.createdAt,
+            ],
+        });
+    }
+    async getCheckpointsByContext(contextId) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "SELECT * FROM checkpoints WHERE context_id = ? ORDER BY sequence ASC",
+            args: [contextId],
+        });
+        return result.rows.map((row) => this.rowToCheckpoint(row));
+    }
+    // ============================================
+    // Handoff Operations
+    // ============================================
+    async saveHandoff(handoff) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        await this.client.execute({
+            sql: `
+        INSERT OR REPLACE INTO handoffs 
+        (id, from_agent_id, to_agent_id, task_id, context_snapshot, notes, timestamp)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `,
+            args: [
+                handoff.id,
+                handoff.fromAgentId,
+                handoff.toAgentId,
+                handoff.taskId,
+                JSON.stringify(handoff.contextSnapshot),
+                handoff.notes || null,
+                handoff.timestamp,
+            ],
+        });
+    }
+    async getHandoffsByAgent(agentId) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: `
+        SELECT * FROM handoffs 
+        WHERE from_agent_id = ? OR to_agent_id = ?
+        ORDER BY timestamp DESC
+      `,
+            args: [agentId, agentId],
+        });
+        return result.rows.map((row) => this.rowToHandoff(row));
+    }
+    // ============================================
+    // Audit Log Operations
+    // ============================================
+    async saveAuditLog(log) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        await this.client.execute({
+            sql: `
+        INSERT INTO audit_logs 
+        (id, timestamp, level, category, agent_id, task_id, action, details)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+            args: [
+                randomUUID(),
+                new Date().toISOString(),
+                log.level,
+                log.category,
+                log.agentId || null,
+                log.taskId || null,
+                log.action,
+                log.details ? JSON.stringify(log.details) : null,
+            ],
+        });
+    }
+    async getAuditLogs(options = {}) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        let sql = "SELECT * FROM audit_logs WHERE 1=1";
+        const args = [];
+        if (options.level) {
+            sql += " AND level = ?";
+            args.push(options.level);
+        }
+        if (options.category) {
+            sql += " AND category = ?";
+            args.push(options.category);
+        }
+        if (options.agentId) {
+            sql += " AND agent_id = ?";
+            args.push(options.agentId);
+        }
+        if (options.since) {
+            sql += " AND timestamp > ?";
+            args.push(options.since.toISOString());
+        }
+        sql += " ORDER BY timestamp DESC";
+        if (options.limit) {
+            sql += " LIMIT ?";
+            args.push(options.limit);
+        }
+        const result = await this.client.execute({ sql, args: args });
+        return result.rows;
+    }
+    // ============================================
+    // Thought Chain Operations
+    // ============================================
+    async saveThoughtChain(chain) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const branchesObj = {};
+        for (const [key, value] of chain.branches.entries()) {
+            branchesObj[key] = value;
+        }
+        await this.client.execute({
+            sql: `
+        INSERT OR REPLACE INTO thought_chains
+        (id, agent_id, task_id, title, thoughts, branches, current_step, status, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+            args: [
+                chain.id,
+                chain.agentId,
+                chain.taskId,
+                chain.title,
+                JSON.stringify(chain.thoughts),
+                JSON.stringify(branchesObj),
+                chain.currentStep,
+                chain.status,
+                chain.createdAt,
+                chain.updatedAt,
+            ],
+        });
+    }
+    async getThoughtChain(chainId) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "SELECT * FROM thought_chains WHERE id = ?",
+            args: [chainId],
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.rowToThoughtChain(result.rows[0]);
+    }
+    async getThoughtChainsByAgent(agentId) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "SELECT * FROM thought_chains WHERE agent_id = ? ORDER BY updated_at DESC",
+            args: [agentId],
+        });
+        return result.rows.map((row) => this.rowToThoughtChain(row));
+    }
+    // ============================================
+    // Parallel Execution Operations
+    // ============================================
+    async saveParallelExecution(execution) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const resultsObj = {};
+        for (const [key, value] of execution.results.entries()) {
+            resultsObj[key] = value;
+        }
+        await this.client.execute({
+            sql: `
+        INSERT OR REPLACE INTO parallel_executions
+        (id, batch_id, tasks, max_concurrency, status, results, aggregated_report, created_at, completed_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+            args: [
+                execution.id,
+                execution.batchId,
+                JSON.stringify(execution.tasks),
+                execution.maxConcurrency,
+                execution.status,
+                JSON.stringify(resultsObj),
+                execution.aggregatedReport || null,
+                execution.createdAt,
+                execution.completedAt || null,
+            ],
+        });
+    }
+    async getParallelExecution(executionId) {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const result = await this.client.execute({
+            sql: "SELECT * FROM parallel_executions WHERE id = ?",
+            args: [executionId],
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.rowToParallelExecution(result.rows[0]);
+    }
+    // ============================================
+    // Statistics
+    // ============================================
+    async getSystemStats() {
+        if (!this.client)
+            throw new Error("Database not initialized");
+        const [totalAgents, agentsByStatus, agentsByType, totalTasks, tasksByStatus, totalContexts, totalCheckpoints, totalHandoffs,] = await Promise.all([
+            this.client.execute("SELECT COUNT(*) as count FROM agents"),
+            this.client.execute("SELECT status, COUNT(*) as count FROM agents GROUP BY status"),
+            this.client.execute("SELECT type, COUNT(*) as count FROM agents GROUP BY type"),
+            this.client.execute("SELECT COUNT(*) as count FROM tasks"),
+            this.client.execute("SELECT status, COUNT(*) as count FROM tasks GROUP BY status"),
+            this.client.execute("SELECT COUNT(*) as count FROM contexts"),
+            this.client.execute("SELECT COUNT(*) as count FROM checkpoints"),
+            this.client.execute("SELECT COUNT(*) as count FROM handoffs"),
+        ]);
+        return {
+            totalAgents: totalAgents.rows[0]?.count ?? 0,
+            agentsByStatus: Object.fromEntries(agentsByStatus.rows.map((r) => [
+                r.status,
+                r.count,
+            ])),
+            agentsByType: Object.fromEntries(agentsByType.rows.map((r) => [
+                r.type,
+                r.count,
+            ])),
+            totalTasks: totalTasks.rows[0]?.count ?? 0,
+            tasksByStatus: Object.fromEntries(tasksByStatus.rows.map((r) => [
+                r.status,
+                r.count,
+            ])),
+            totalContexts: totalContexts.rows[0]?.count ?? 0,
+            totalCheckpoints: totalCheckpoints.rows[0]?.count ?? 0,
+            totalHandoffs: totalHandoffs.rows[0]?.count ?? 0,
+        };
+    }
+    // ============================================
+    // Safe JSON Parsing
+    // ============================================
+    safeJsonParse(json, defaultValue) {
+        if (!json)
+            return defaultValue;
+        try {
+            return JSON.parse(json);
+        }
+        catch (error) {
+            logger.error("Failed to parse JSON from database", {
+                error: error instanceof Error ? error.message : String(error),
+                json: json.substring(0, 200),
+            });
+            return defaultValue;
+        }
+    }
+    // ============================================
+    // Row Converters
+    // ============================================
+    rowToAgent(row) {
+        return {
+            id: row.id,
+            type: row.type,
+            name: row.name,
+            mode: row.mode || "plan",
+            status: row.status,
+            currentTask: row.current_task,
+            capabilities: this.safeJsonParse(row.capabilities, []),
+            metadata: this.safeJsonParse(row.metadata, {}),
+            createdAt: row.created_at,
+            lastActiveAt: row.last_active_at,
+            healthCheckAt: row.health_check_at,
+        };
+    }
+    rowToTask(row) {
+        return {
+            id: row.id,
+            agentId: row.agent_id,
+            type: row.type,
+            description: row.description,
+            context: this.safeJsonParse(row.context, {}),
+            status: row.status,
+            priority: row.priority || 5,
+            result: row.result ? this.safeJsonParse(row.result, undefined) : undefined,
+            error: row.error,
+            createdAt: row.created_at,
+            startedAt: row.started_at,
+            completedAt: row.completed_at,
+            timeout: row.timeout || 60,
+        };
+    }
+    rowToContext(row) {
+        return {
+            id: row.id,
+            agentId: row.agent_id,
+            messages: this.safeJsonParse(row.messages, []),
+            artifacts: this.safeJsonParse(row.artifacts, []),
+            checkpoints: this.safeJsonParse(row.checkpoints, []),
+            summary: row.summary,
+            tokenCount: row.token_count || 0,
+            maxTokens: row.max_tokens || 4000,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+    rowToCheckpoint(row) {
+        return {
+            id: row.id,
+            contextId: row.context_id,
+            sequence: row.sequence,
+            messages: this.safeJsonParse(row.messages, []),
+            artifacts: this.safeJsonParse(row.artifacts, []),
+            thoughtChainId: row.thought_chain_id,
+            createdAt: row.created_at,
+        };
+    }
+    rowToHandoff(row) {
+        return {
+            id: row.id,
+            fromAgentId: row.from_agent_id,
+            toAgentId: row.to_agent_id,
+            taskId: row.task_id,
+            contextSnapshot: this.safeJsonParse(row.context_snapshot, { messages: [], artifacts: [] }),
+            notes: row.notes,
+            timestamp: row.timestamp,
+        };
+    }
+    rowToThoughtChain(row) {
+        const branchesObj = this.safeJsonParse(row.branches, {});
+        const branches = new Map();
+        for (const [key, value] of Object.entries(branchesObj)) {
+            branches.set(key, value);
+        }
+        return {
+            id: row.id,
+            agentId: row.agent_id,
+            taskId: row.task_id,
+            title: row.title,
+            thoughts: this.safeJsonParse(row.thoughts, []),
+            branches,
+            currentStep: row.current_step || 0,
+            status: row.status || "active",
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+    rowToParallelExecution(row) {
+        const resultsObj = this.safeJsonParse(row.results, {});
+        const results = new Map();
+        for (const [key, value] of Object.entries(resultsObj)) {
+            results.set(key, value);
+        }
+        return {
+            id: row.id,
+            batchId: row.batch_id,
+            tasks: this.safeJsonParse(row.tasks, []),
+            maxConcurrency: row.max_concurrency || 5,
+            status: row.status || "pending",
+            results,
+            aggregatedReport: row.aggregated_report,
+            createdAt: row.created_at,
+            completedAt: row.completed_at,
+        };
+    }
+    /**
+     * Close database connection
+     */
+    async close() {
+        if (this.client) {
+            try {
+                // Attempt to close the client if it has a close method
+                await this.client.close?.();
+            }
+            catch (error) {
+                // Log but don't throw - client might not have close method or already closed
+                logger.debug("Note during database close (non-critical)", {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            this.client = null;
+            this.initialized = false;
+            logger.info("Database connection closed");
+        }
+    }
+}
+// Export singleton instance
+export const database = new DatabaseManager();
+//# sourceMappingURL=database.js.map