memory-journal-mcp 3.0.0

package/dist/database/SqliteAdapter.js

@@ -0,0 +1,736 @@
+/**
+ * Memory Journal MCP Server - SQLite Database Adapter
+ *
+ * Manages SQLite database with FTS5 full-text search using sql.js.
+ * Note: sql.js is pure JavaScript, no native compilation required.
+ */
+import initSqlJs from 'sql.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { logger } from '../utils/logger.js';
+// Schema SQL for initialization
+const SCHEMA_SQL = `
+-- Main journal entries table
+CREATE TABLE IF NOT EXISTS memory_journal (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entry_type TEXT NOT NULL,
+    content TEXT NOT NULL,
+    timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
+    is_personal INTEGER DEFAULT 1,
+    significance_type TEXT,
+    auto_context TEXT,
+    deleted_at TEXT,
+    -- GitHub integration fields
+    project_number INTEGER,
+    project_owner TEXT,
+    issue_number INTEGER,
+    issue_url TEXT,
+    pr_number INTEGER,
+    pr_url TEXT,
+    pr_status TEXT,
+    workflow_run_id INTEGER,
+    workflow_name TEXT,
+    workflow_status TEXT
+);
+
+-- Tags table
+CREATE TABLE IF NOT EXISTS tags (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    usage_count INTEGER DEFAULT 0
+);
+
+-- Junction table for entry-tag relationships
+CREATE TABLE IF NOT EXISTS entry_tags (
+    entry_id INTEGER NOT NULL,
+    tag_id INTEGER NOT NULL,
+    PRIMARY KEY (entry_id, tag_id),
+    FOREIGN KEY (entry_id) REFERENCES memory_journal(id) ON DELETE CASCADE,
+    FOREIGN KEY (tag_id) REFERENCES tags(id) ON DELETE CASCADE
+);
+
+-- Relationships between entries
+CREATE TABLE IF NOT EXISTS relationships (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    from_entry_id INTEGER NOT NULL,
+    to_entry_id INTEGER NOT NULL,
+    relationship_type TEXT NOT NULL,
+    description TEXT,
+    created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (from_entry_id) REFERENCES memory_journal(id) ON DELETE CASCADE,
+    FOREIGN KEY (to_entry_id) REFERENCES memory_journal(id) ON DELETE CASCADE
+);
+
+-- Embeddings for vector search (stored as JSON for sql.js compatibility)
+CREATE TABLE IF NOT EXISTS embeddings (
+    entry_id INTEGER PRIMARY KEY,
+    embedding TEXT NOT NULL,
+    model_name TEXT NOT NULL,
+    FOREIGN KEY (entry_id) REFERENCES memory_journal(id) ON DELETE CASCADE
+);
+
+-- Indexes for performance
+CREATE INDEX IF NOT EXISTS idx_memory_journal_timestamp ON memory_journal(timestamp);
+CREATE INDEX IF NOT EXISTS idx_memory_journal_type ON memory_journal(entry_type);
+CREATE INDEX IF NOT EXISTS idx_memory_journal_personal ON memory_journal(is_personal);
+CREATE INDEX IF NOT EXISTS idx_memory_journal_deleted ON memory_journal(deleted_at);
+CREATE INDEX IF NOT EXISTS idx_memory_journal_project ON memory_journal(project_number);
+CREATE INDEX IF NOT EXISTS idx_memory_journal_issue ON memory_journal(issue_number);
+CREATE INDEX IF NOT EXISTS idx_memory_journal_pr ON memory_journal(pr_number);
+CREATE INDEX IF NOT EXISTS idx_tags_name ON tags(name);
+CREATE INDEX IF NOT EXISTS idx_entry_tags_entry ON entry_tags(entry_id);
+CREATE INDEX IF NOT EXISTS idx_entry_tags_tag ON entry_tags(tag_id);
+CREATE INDEX IF NOT EXISTS idx_relationships_from ON relationships(from_entry_id);
+CREATE INDEX IF NOT EXISTS idx_relationships_to ON relationships(to_entry_id);
+`;
+/**
+ * SQLite Database Adapter for Memory Journal using sql.js
+ */
+export class SqliteAdapter {
+    db = null;
+    dbPath;
+    initialized = false;
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+    }
+    /**
+     * Initialize the database (must be called before using)
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        const SQL = await initSqlJs();
+        // Try to load existing database
+        let dbBuffer = null;
+        if (fs.existsSync(this.dbPath)) {
+            try {
+                dbBuffer = fs.readFileSync(this.dbPath);
+            }
+            catch {
+                // File doesn't exist or can't be read, create new
+            }
+        }
+        if (dbBuffer) {
+            this.db = new SQL.Database(dbBuffer);
+        }
+        else {
+            this.db = new SQL.Database();
+            // Ensure directory exists
+            const dir = path.dirname(this.dbPath);
+            if (dir && !fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+        // Initialize schema
+        this.db.run(SCHEMA_SQL);
+        this.initialized = true;
+        logger.info('Database opened', { module: 'SqliteAdapter', dbPath: this.dbPath });
+        // Save after initialization
+        this.save();
+    }
+    /**
+     * Save database to disk
+     */
+    save() {
+        if (!this.db)
+            return;
+        const data = this.db.export();
+        const buffer = Buffer.from(data);
+        fs.writeFileSync(this.dbPath, buffer);
+    }
+    /**
+     * Close database connection
+     */
+    close() {
+        if (this.db) {
+            this.save();
+            this.db.close();
+            this.db = null;
+        }
+        logger.info('Database closed', { module: 'SqliteAdapter' });
+    }
+    /**
+     * Ensure database is initialized
+     */
+    ensureDb() {
+        if (!this.db) {
+            throw new Error('Database not initialized. Call initialize() first.');
+        }
+        return this.db;
+    }
+    // =========================================================================
+    // Entry Operations
+    // =========================================================================
+    /**
+     * Create a new journal entry
+     */
+    createEntry(input) {
+        const db = this.ensureDb();
+        const { content, entryType = 'personal_reflection', tags = [], isPersonal = true, significanceType = null, autoContext = null, projectNumber, projectOwner, issueNumber, issueUrl, prNumber, prUrl, prStatus, workflowRunId, workflowName, workflowStatus, } = input;
+        db.run(`
+            INSERT INTO memory_journal (
+                entry_type, content, is_personal, significance_type, auto_context,
+                project_number, project_owner, issue_number, issue_url,
+                pr_number, pr_url, pr_status, workflow_run_id, workflow_name, workflow_status
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `, [
+            entryType,
+            content,
+            isPersonal ? 1 : 0,
+            significanceType,
+            autoContext,
+            projectNumber ?? null,
+            projectOwner ?? null,
+            issueNumber ?? null,
+            issueUrl ?? null,
+            prNumber ?? null,
+            prUrl ?? null,
+            prStatus ?? null,
+            workflowRunId ?? null,
+            workflowName ?? null,
+            workflowStatus ?? null,
+        ]);
+        // Get the inserted ID
+        const result = db.exec('SELECT last_insert_rowid() as id');
+        const entryId = result[0]?.values[0]?.[0];
+        // Create tags and link them
+        if (tags.length > 0) {
+            this.linkTagsToEntry(entryId, tags);
+        }
+        this.save();
+        logger.info('Entry created', {
+            module: 'SqliteAdapter',
+            operation: 'createEntry',
+            entityId: entryId
+        });
+        const entry = this.getEntryById(entryId);
+        if (!entry) {
+            throw new Error(`Failed to retrieve created entry with ID ${entryId}`);
+        }
+        return entry;
+    }
+    /**
+     * Get entry by ID
+     */
+    getEntryById(id) {
+        const db = this.ensureDb();
+        const result = db.exec(`SELECT * FROM memory_journal WHERE id = ? AND deleted_at IS NULL`, [id]);
+        if (result.length === 0 || result[0]?.values.length === 0)
+            return null;
+        const columns = result[0]?.columns ?? [];
+        const values = result[0]?.values[0] ?? [];
+        const row = this.rowToObject(columns, values);
+        return this.rowToEntry(row);
+    }
+    /**
+     * Get recent entries
+     */
+    getRecentEntries(limit = 10, isPersonal) {
+        const db = this.ensureDb();
+        let sql = `SELECT * FROM memory_journal WHERE deleted_at IS NULL`;
+        const params = [];
+        if (isPersonal !== undefined) {
+            sql += ` AND is_personal = ?`;
+            params.push(isPersonal ? 1 : 0);
+        }
+        sql += ` ORDER BY timestamp DESC LIMIT ?`;
+        params.push(limit);
+        const result = db.exec(sql, params);
+        if (result.length === 0)
+            return [];
+        const columns = result[0]?.columns ?? [];
+        return (result[0]?.values ?? []).map(values => this.rowToEntry(this.rowToObject(columns, values)));
+    }
+    /**
+     * Update an entry
+     */
+    updateEntry(id, updates) {
+        const db = this.ensureDb();
+        const entry = this.getEntryById(id);
+        if (!entry)
+            return null;
+        const setClause = [];
+        const params = [];
+        if (updates.content !== undefined) {
+            setClause.push('content = ?');
+            params.push(updates.content);
+        }
+        if (updates.entryType !== undefined) {
+            setClause.push('entry_type = ?');
+            params.push(updates.entryType);
+        }
+        if (updates.isPersonal !== undefined) {
+            setClause.push('is_personal = ?');
+            params.push(updates.isPersonal ? 1 : 0);
+        }
+        if (setClause.length > 0) {
+            params.push(id);
+            db.run(`UPDATE memory_journal SET ${setClause.join(', ')} WHERE id = ?`, params);
+        }
+        // Update tags if provided
+        if (updates.tags !== undefined) {
+            db.run('DELETE FROM entry_tags WHERE entry_id = ?', [id]);
+            this.linkTagsToEntry(id, updates.tags);
+        }
+        this.save();
+        logger.info('Entry updated', {
+            module: 'SqliteAdapter',
+            operation: 'updateEntry',
+            entityId: id
+        });
+        return this.getEntryById(id);
+    }
+    /**
+     * Soft delete an entry
+     */
+    deleteEntry(id, permanent = false) {
+        const db = this.ensureDb();
+        if (permanent) {
+            db.run('DELETE FROM memory_journal WHERE id = ?', [id]);
+        }
+        else {
+            db.run(`UPDATE memory_journal SET deleted_at = datetime('now') WHERE id = ?`, [id]);
+        }
+        this.save();
+        return true;
+    }
+    // =========================================================================
+    // Search Operations
+    // =========================================================================
+    /**
+     * Full-text search entries (using LIKE for sql.js - FTS5 not supported)
+     */
+    searchEntries(query, options = {}) {
+        const db = this.ensureDb();
+        const { limit = 10, isPersonal, projectNumber, issueNumber, prNumber } = options;
+        let sql = `
+            SELECT * FROM memory_journal 
+            WHERE deleted_at IS NULL AND content LIKE ?
+        `;
+        const params = [`%${query}%`];
+        if (isPersonal !== undefined) {
+            sql += ` AND is_personal = ?`;
+            params.push(isPersonal ? 1 : 0);
+        }
+        if (projectNumber !== undefined) {
+            sql += ` AND project_number = ?`;
+            params.push(projectNumber);
+        }
+        if (issueNumber !== undefined) {
+            sql += ` AND issue_number = ?`;
+            params.push(issueNumber);
+        }
+        if (prNumber !== undefined) {
+            sql += ` AND pr_number = ?`;
+            params.push(prNumber);
+        }
+        sql += ` ORDER BY timestamp DESC LIMIT ?`;
+        params.push(limit);
+        const result = db.exec(sql, params);
+        if (result.length === 0)
+            return [];
+        const columns = result[0]?.columns ?? [];
+        return (result[0]?.values ?? []).map(values => this.rowToEntry(this.rowToObject(columns, values)));
+    }
+    /**
+     * Search by date range
+     */
+    searchByDateRange(startDate, endDate, options = {}) {
+        const db = this.ensureDb();
+        const { entryType, tags, isPersonal, projectNumber } = options;
+        let sql = `
+            SELECT DISTINCT m.* FROM memory_journal m
+            LEFT JOIN entry_tags et ON m.id = et.entry_id
+            LEFT JOIN tags t ON et.tag_id = t.id
+            WHERE m.deleted_at IS NULL
+            AND m.timestamp >= ? AND m.timestamp <= ?
+        `;
+        const params = [startDate, endDate + ' 23:59:59'];
+        if (entryType) {
+            sql += ` AND m.entry_type = ?`;
+            params.push(entryType);
+        }
+        if (isPersonal !== undefined) {
+            sql += ` AND m.is_personal = ?`;
+            params.push(isPersonal ? 1 : 0);
+        }
+        if (projectNumber !== undefined) {
+            sql += ` AND m.project_number = ?`;
+            params.push(projectNumber);
+        }
+        if (tags && tags.length > 0) {
+            const placeholders = tags.map(() => '?').join(',');
+            sql += ` AND t.name IN (${placeholders})`;
+            params.push(...tags);
+        }
+        sql += ` ORDER BY m.timestamp DESC`;
+        const result = db.exec(sql, params);
+        if (result.length === 0)
+            return [];
+        const columns = result[0]?.columns ?? [];
+        return (result[0]?.values ?? []).map(values => this.rowToEntry(this.rowToObject(columns, values)));
+    }
+    // =========================================================================
+    // Tag Operations
+    // =========================================================================
+    /**
+     * Get or create tags and link to entry
+     */
+    linkTagsToEntry(entryId, tagNames) {
+        const db = this.ensureDb();
+        for (const tagName of tagNames) {
+            // Insert or ignore tag
+            db.run('INSERT OR IGNORE INTO tags (name, usage_count) VALUES (?, 0)', [tagName]);
+            // Get tag ID
+            const result = db.exec('SELECT id FROM tags WHERE name = ?', [tagName]);
+            const tagId = result[0]?.values[0]?.[0];
+            if (tagId !== undefined) {
+                // Link tag to entry
+                db.run('INSERT OR IGNORE INTO entry_tags (entry_id, tag_id) VALUES (?, ?)', [entryId, tagId]);
+                // Increment usage
+                db.run('UPDATE tags SET usage_count = usage_count + 1 WHERE id = ?', [tagId]);
+            }
+        }
+    }
+    /**
+     * Get tags for an entry
+     */
+    getTagsForEntry(entryId) {
+        const db = this.ensureDb();
+        const result = db.exec(`
+            SELECT t.name FROM tags t
+            JOIN entry_tags et ON t.id = et.tag_id
+            WHERE et.entry_id = ?
+        `, [entryId]);
+        if (result.length === 0)
+            return [];
+        return (result[0]?.values ?? []).map((v) => v[0]);
+    }
+    /**
+     * List all tags
+     */
+    listTags() {
+        const db = this.ensureDb();
+        const result = db.exec('SELECT * FROM tags ORDER BY usage_count DESC');
+        if (result.length === 0)
+            return [];
+        return (result[0]?.values ?? []).map(v => ({
+            id: v[0],
+            name: v[1],
+            usageCount: v[2],
+        }));
+    }
+    // =========================================================================
+    // Relationship Operations
+    // =========================================================================
+    /**
+     * Link two entries
+     */
+    linkEntries(fromEntryId, toEntryId, relationshipType, description) {
+        const db = this.ensureDb();
+        db.run(`
+            INSERT INTO relationships (from_entry_id, to_entry_id, relationship_type, description)
+            VALUES (?, ?, ?, ?)
+        `, [fromEntryId, toEntryId, relationshipType, description ?? null]);
+        const result = db.exec('SELECT last_insert_rowid() as id');
+        const id = result[0]?.values[0]?.[0];
+        this.save();
+        return {
+            id,
+            fromEntryId,
+            toEntryId,
+            relationshipType,
+            description: description ?? null,
+            createdAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * Get relationships for an entry
+     */
+    getRelationships(entryId) {
+        const db = this.ensureDb();
+        const result = db.exec(`
+            SELECT * FROM relationships
+            WHERE from_entry_id = ? OR to_entry_id = ?
+        `, [entryId, entryId]);
+        if (result.length === 0)
+            return [];
+        const columns = result[0]?.columns ?? [];
+        return (result[0]?.values ?? []).map((values) => {
+            const row = this.rowToObject(columns, values);
+            return {
+                id: row['id'],
+                fromEntryId: row['from_entry_id'],
+                toEntryId: row['to_entry_id'],
+                relationshipType: row['relationship_type'],
+                description: row['description'],
+                createdAt: row['created_at'],
+            };
+        });
+    }
+    // =========================================================================
+    // Statistics
+    // =========================================================================
+    /**
+     * Get entry statistics
+     */
+    getStatistics(groupBy = 'week') {
+        const db = this.ensureDb();
+        // Total entries
+        const totalResult = db.exec(`
+            SELECT COUNT(*) as count FROM memory_journal WHERE deleted_at IS NULL
+        `);
+        const totalEntries = totalResult[0]?.values[0]?.[0] ?? 0;
+        // By type
+        const byTypeResult = db.exec(`
+            SELECT entry_type, COUNT(*) as count 
+            FROM memory_journal 
+            WHERE deleted_at IS NULL 
+            GROUP BY entry_type
+        `);
+        const entriesByType = {};
+        for (const row of (byTypeResult[0]?.values ?? [])) {
+            entriesByType[row[0]] = row[1];
+        }
+        // By period
+        let dateFormat;
+        switch (groupBy) {
+            case 'day':
+                dateFormat = '%Y-%m-%d';
+                break;
+            case 'month':
+                dateFormat = '%Y-%m';
+                break;
+            default:
+                dateFormat = '%Y-W%W';
+        }
+        const byPeriodResult = db.exec(`
+            SELECT strftime('${dateFormat}', timestamp) as period, COUNT(*) as count
+            FROM memory_journal
+            WHERE deleted_at IS NULL
+            GROUP BY period
+            ORDER BY period DESC
+            LIMIT 52
+        `);
+        const entriesByPeriod = (byPeriodResult[0]?.values ?? []).map((v) => ({
+            period: v[0],
+            count: v[1],
+        }));
+        return {
+            totalEntries,
+            entriesByType,
+            entriesByPeriod,
+        };
+    }
+    // =========================================================================
+    // Backup Operations
+    // =========================================================================
+    /**
+     * Get the backups directory path (relative to database location)
+     */
+    getBackupsDir() {
+        return path.join(path.dirname(this.dbPath), 'backups');
+    }
+    /**
+     * Export database to a backup file
+     * @param backupName Optional custom name (default: timestamp-based)
+     * @returns Backup file info
+     */
+    exportToFile(backupName) {
+        const db = this.ensureDb();
+        const backupsDir = this.getBackupsDir();
+        // Ensure backups directory exists
+        if (!fs.existsSync(backupsDir)) {
+            fs.mkdirSync(backupsDir, { recursive: true });
+        }
+        // Generate filename with timestamp
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const sanitizedName = backupName
+            ? backupName.replace(/[/\\:*?"<>|]/g, '_').slice(0, 50)
+            : `backup_${timestamp}`;
+        const filename = `${sanitizedName}.db`;
+        const backupPath = path.join(backupsDir, filename);
+        // Export database
+        const data = db.export();
+        const buffer = Buffer.from(data);
+        fs.writeFileSync(backupPath, buffer);
+        const stats = fs.statSync(backupPath);
+        logger.info('Backup created', {
+            module: 'SqliteAdapter',
+            operation: 'exportToFile',
+            context: { backupPath, sizeBytes: stats.size }
+        });
+        return {
+            filename,
+            path: backupPath,
+            sizeBytes: stats.size,
+        };
+    }
+    /**
+     * List all available backup files
+     * @returns Array of backup file information
+     */
+    listBackups() {
+        const backupsDir = this.getBackupsDir();
+        if (!fs.existsSync(backupsDir)) {
+            return [];
+        }
+        const files = fs.readdirSync(backupsDir);
+        const backups = [];
+        for (const filename of files) {
+            if (!filename.endsWith('.db'))
+                continue;
+            const filePath = path.join(backupsDir, filename);
+            try {
+                const stats = fs.statSync(filePath);
+                if (stats.isFile()) {
+                    backups.push({
+                        filename,
+                        path: filePath,
+                        sizeBytes: stats.size,
+                        createdAt: stats.birthtime.toISOString(),
+                    });
+                }
+            }
+            catch {
+                // Skip files that can't be read
+            }
+        }
+        // Sort by creation time, newest first
+        backups.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        return backups;
+    }
+    /**
+     * Restore database from a backup file
+     * @param filename Backup filename to restore from
+     * @returns Statistics about the restore operation
+     */
+    async restoreFromFile(filename) {
+        // Validate filename (prevent path traversal)
+        if (filename.includes('/') || filename.includes('\\') || filename.includes('..')) {
+            throw new Error('Invalid backup filename: path separators not allowed');
+        }
+        const backupsDir = this.getBackupsDir();
+        const backupPath = path.join(backupsDir, filename);
+        if (!fs.existsSync(backupPath)) {
+            throw new Error(`Backup file not found: ${filename}`);
+        }
+        // Get current entry count for comparison
+        const db = this.ensureDb();
+        const currentCountResult = db.exec('SELECT COUNT(*) FROM memory_journal WHERE deleted_at IS NULL');
+        const previousEntryCount = currentCountResult[0]?.values[0]?.[0] ?? 0;
+        // Create auto-backup before restore
+        this.exportToFile(`pre_restore_${new Date().toISOString().replace(/[:.]/g, '-')}`);
+        // Close current database
+        this.db?.close();
+        this.db = null;
+        this.initialized = false;
+        // Read backup file
+        const backupBuffer = fs.readFileSync(backupPath);
+        // Initialize new database from backup
+        const SQL = await import('sql.js').then(m => m.default());
+        this.db = new SQL.Database(backupBuffer);
+        this.initialized = true;
+        // Get new entry count
+        const newCountResult = this.db.exec('SELECT COUNT(*) FROM memory_journal WHERE deleted_at IS NULL');
+        const newEntryCount = newCountResult[0]?.values[0]?.[0] ?? 0;
+        // Save to main database path
+        this.save();
+        logger.info('Database restored from backup', {
+            module: 'SqliteAdapter',
+            operation: 'restoreFromFile',
+            context: { backupPath, previousEntryCount, newEntryCount }
+        });
+        return {
+            restoredFrom: filename,
+            previousEntryCount,
+            newEntryCount,
+        };
+    }
+    // =========================================================================
+    // Health Status
+    // =========================================================================
+    /**
+     * Get database health status for diagnostics
+     */
+    getHealthStatus() {
+        const db = this.ensureDb();
+        // Get file size
+        let sizeBytes = 0;
+        try {
+            const stats = fs.statSync(this.dbPath);
+            sizeBytes = stats.size;
+        }
+        catch {
+            // File may not exist on disk yet
+        }
+        // Entry counts
+        const entryResult = db.exec('SELECT COUNT(*) FROM memory_journal WHERE deleted_at IS NULL');
+        const deletedResult = db.exec('SELECT COUNT(*) FROM memory_journal WHERE deleted_at IS NOT NULL');
+        const relResult = db.exec('SELECT COUNT(*) FROM relationships');
+        const tagResult = db.exec('SELECT COUNT(*) FROM tags');
+        const entryCount = entryResult[0]?.values[0]?.[0] ?? 0;
+        const deletedEntryCount = deletedResult[0]?.values[0]?.[0] ?? 0;
+        const relationshipCount = relResult[0]?.values[0]?.[0] ?? 0;
+        const tagCount = tagResult[0]?.values[0]?.[0] ?? 0;
+        // Backup info
+        const backups = this.listBackups();
+        const lastBackup = backups[0] ?? null;
+        return {
+            database: {
+                path: this.dbPath,
+                sizeBytes,
+                entryCount,
+                deletedEntryCount,
+                relationshipCount,
+                tagCount,
+            },
+            backups: {
+                directory: this.getBackupsDir(),
+                count: backups.length,
+                lastBackup: lastBackup ? {
+                    filename: lastBackup.filename,
+                    createdAt: lastBackup.createdAt,
+                    sizeBytes: lastBackup.sizeBytes,
+                } : null,
+            },
+        };
+    }
+    // =========================================================================
+    // Helpers
+    // =========================================================================
+    /**
+     * Convert columns and values to object
+     */
+    rowToObject(columns, values) {
+        const obj = {};
+        columns.forEach((col, i) => {
+            obj[col] = values[i];
+        });
+        return obj;
+    }
+    /**
+     * Convert database row to JournalEntry
+     */
+    rowToEntry(row) {
+        const id = row['id'];
+        return {
+            id,
+            entryType: row['entry_type'],
+            content: row['content'],
+            timestamp: row['timestamp'],
+            isPersonal: row['is_personal'] === 1,
+            significanceType: row['significance_type'],
+            autoContext: row['auto_context'],
+            deletedAt: row['deleted_at'],
+            tags: this.getTagsForEntry(id),
+        };
+    }
+    /**
+     * Get raw database for advanced operations
+     */
+    getRawDb() {
+        return this.ensureDb();
+    }
+}
+//# sourceMappingURL=SqliteAdapter.js.map