memory-journal-mcp 6.1.2 → 6.2.1

package/src/database/sqlite-adapter/index.ts

@@ -1,265 +0,0 @@
-import type {
-    JournalEntry,
-    Tag,
-    Relationship,
-    EntryType,
-    RelationshipType,
-    ImportanceResult,
-} from '../../types/index.js'
-import type { CreateEntryInput } from '../core/schema.js'
-import type { IDatabaseAdapter, QueryResult } from '../core/interfaces.js'
-
-import { NativeConnectionManager } from './native-connection.js'
-import { TagsManager } from './tags.js'
-import { EntriesManager } from './entries/index.js'
-import { RelationshipsManager } from './relationships.js'
-import { BackupManager } from './backup.js'
-import * as fs from 'node:fs'
-
-/**
- * SQLite Database Adapter for Memory Journal using better-sqlite3 native driver
- */
-export class DatabaseAdapter implements IDatabaseAdapter {
-    private connection: NativeConnectionManager
-    private tagsMgr: TagsManager
-    private entriesMgr: EntriesManager
-    private relationshipsMgr: RelationshipsManager
-    private backupMgr: BackupManager
-
-    constructor(dbPath: string) {
-        this.connection = new NativeConnectionManager(dbPath)
-        this.tagsMgr = new TagsManager(this.connection)
-        this.entriesMgr = new EntriesManager(this.connection, this.tagsMgr)
-        this.relationshipsMgr = new RelationshipsManager(this.connection, this.entriesMgr)
-        this.backupMgr = new BackupManager(this.connection)
-    }
-
-    async initialize(): Promise<void> {
-        return this.connection.initialize()
-    }
-
-    applyTeamSchema(): void {
-        this.connection.applyTeamSchema()
-    }
-
-    flushSave(): void {
-        this.connection.flushSave()
-    }
-
-    close(): void {
-        this.connection.close()
-    }
-
-    createEntry(input: CreateEntryInput): JournalEntry {
-        return this.entriesMgr.createEntry(input)
-    }
-
-    getEntryById(id: number): JournalEntry | null {
-        return this.entriesMgr.getEntryById(id)
-    }
-
-    getEntryByIdIncludeDeleted(id: number): JournalEntry | null {
-        return this.entriesMgr.getEntryByIdIncludeDeleted(id)
-    }
-
-    getEntriesByIds(ids: number[]): Map<number, JournalEntry> {
-        return this.entriesMgr.getEntriesByIds(ids)
-    }
-
-    calculateImportance(entryId: number): ImportanceResult {
-        return this.entriesMgr.calculateImportance(entryId)
-    }
-
-    getRecentEntries(limit?: number, isPersonal?: boolean): JournalEntry[] {
-        return this.entriesMgr.getRecentEntries(limit ?? 10, isPersonal)
-    }
-
-    getEntriesPage(offset: number, limit: number): JournalEntry[] {
-        return this.entriesMgr.getEntriesPage(offset, limit)
-    }
-
-    getActiveEntryCount(): number {
-        return this.entriesMgr.getActiveEntryCount()
-    }
-
-    updateEntry(
-        id: number,
-        updates: {
-            content?: string
-            entryType?: EntryType
-            tags?: string[]
-            isPersonal?: boolean
-        }
-    ): JournalEntry | null {
-        return this.entriesMgr.updateEntry(id, updates)
-    }
-
-    deleteEntry(id: number, permanent = false): boolean {
-        return this.entriesMgr.deleteEntry(id, permanent)
-    }
-
-    searchEntries(
-        query: string,
-        options?: {
-            limit?: number
-            isPersonal?: boolean
-            projectNumber?: number
-            issueNumber?: number
-            prNumber?: number
-            prStatus?: string
-            workflowRunId?: number
-        }
-    ): JournalEntry[] {
-        return this.entriesMgr.searchEntries(query, options)
-    }
-
-    searchByDateRange(
-        startDate: string,
-        endDate: string,
-        options?: {
-            entryType?: EntryType
-            tags?: string[]
-            isPersonal?: boolean
-            projectNumber?: number
-            issueNumber?: number
-            prNumber?: number
-            workflowRunId?: number
-            limit?: number
-        }
-    ): JournalEntry[] {
-        return this.entriesMgr.searchByDateRange(startDate, endDate, options)
-    }
-
-    getStatistics(
-        groupBy?: 'day' | 'week' | 'month',
-        startDate?: string,
-        endDate?: string,
-        projectBreakdown?: boolean
-    ): ReturnType<EntriesManager['getStatistics']> {
-        return this.entriesMgr.getStatistics(groupBy, startDate, endDate, projectBreakdown)
-    }
-
-    getTagsForEntry(entryId: number): string[] {
-        return this.tagsMgr.getTagsForEntry(entryId)
-    }
-
-    listTags(): Tag[] {
-        return this.tagsMgr.listTags()
-    }
-
-    mergeTags(
-        sourceTag: string,
-        targetTag: string
-    ): { entriesUpdated: number; sourceDeleted: boolean } {
-        return this.tagsMgr.mergeTags(sourceTag, targetTag)
-    }
-
-    linkEntries(
-        fromEntryId: number,
-        toEntryId: number,
-        relationshipType: RelationshipType,
-        description?: string
-    ): Relationship {
-        return this.relationshipsMgr.linkEntries(
-            fromEntryId,
-            toEntryId,
-            relationshipType,
-            description
-        )
-    }
-
-    getRelationships(entryId: number): Relationship[] {
-        return this.relationshipsMgr.getRelationships(entryId)
-    }
-
-    getBackupsDir(): string {
-        return this.connection.getBackupsDir()
-    }
-
-    async exportToFile(
-        backupName?: string
-    ): Promise<{ filename: string; path: string; sizeBytes: number }> {
-        return this.backupMgr.exportToFile(backupName)
-    }
-
-    listBackups(): { filename: string; path: string; sizeBytes: number; createdAt: string }[] {
-        return this.backupMgr.listBackups()
-    }
-
-    deleteOldBackups(keepCount: number): { deleted: string[]; kept: number } {
-        return this.backupMgr.deleteOldBackups(keepCount)
-    }
-
-    async restoreFromFile(filename: string): Promise<{
-        restoredFrom: string
-        previousEntryCount: number
-        newEntryCount: number
-    }> {
-        return this.backupMgr.restoreFromFile(filename)
-    }
-
-    getHealthStatus(): ReturnType<IDatabaseAdapter['getHealthStatus']> {
-        // Safe query execution through the connection interface
-        const dbPath = this.connection.getDbPath()
-
-        let sizeBytes = 0
-        try {
-            const stats = fs.statSync(dbPath)
-            sizeBytes = stats.size
-        } catch {
-            // File may not exist on disk yet
-        }
-
-        // Combined health counts in a single query (batch instead of 4 serial queries)
-        const countsResult = this.connection.exec(`
-            SELECT
-                (SELECT COUNT(*) FROM memory_journal WHERE deleted_at IS NULL) AS entry_count,
-                (SELECT COUNT(*) FROM memory_journal WHERE deleted_at IS NOT NULL) AS deleted_count,
-                (SELECT COUNT(*) FROM relationships) AS rel_count,
-                (SELECT COUNT(*) FROM tags) AS tag_count
-        `)
-
-        const row = countsResult[0]?.values[0]
-        const entryCount = (row?.[0] as number) ?? 0
-        const deletedEntryCount = (row?.[1] as number) ?? 0
-        const relationshipCount = (row?.[2] as number) ?? 0
-        const tagCount = (row?.[3] as number) ?? 0
-
-        const backups = this.listBackups()
-        const lastBackup = backups[0] ?? null
-
-        return {
-            database: {
-                path: 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,
-            },
-        }
-    }
-
-    pragma(command: string): void {
-        this.connection.pragma(command)
-    }
-
-    getRawDb(): unknown {
-        return this.connection.getRawDb()
-    }
-
-    executeRawQuery(sql: string, params?: unknown[]): QueryResult[] {
-        return this.connection.exec(sql, params)
-    }
-}

package/src/database/sqlite-adapter/native-connection.ts

@@ -1,301 +0,0 @@
-import DatabaseAdapter from 'better-sqlite3'
-import type { Database } from 'better-sqlite3'
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-import { logger } from '../../utils/logger.js'
-import { ConnectionError } from '../../types/errors.js'
-import { SCHEMA_SQL, TEAM_SCHEMA_SQL } from '../core/schema.js'
-import type { IDatabaseConnection, QueryResult } from '../core/interfaces.js'
-
-/**
- * Pre-compiled regex to detect SQL mutation statements.
- * Hoisted to module scope to avoid recompilation on every exec() call.
- */
-const IS_MUTATION_RE =
-    /^\s*(INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|PRAGMA (?!table_info|foreign_key_list|index_info|index_list|journal_mode|synchronous|temp_store))./i
-
-/**
- * Shared migration columns required by both personal and team schemas.
- * Adding a new column here ensures it is applied in both migrateSchema() and applyTeamSchema().
- */
-const SHARED_MIGRATION_COLUMNS: { name: string; sql: string }[] = [
-    {
-        name: 'significance_type',
-        sql: 'ALTER TABLE memory_journal ADD COLUMN significance_type TEXT',
-    },
-    { name: 'auto_context', sql: 'ALTER TABLE memory_journal ADD COLUMN auto_context TEXT' },
-    { name: 'deleted_at', sql: 'ALTER TABLE memory_journal ADD COLUMN deleted_at TEXT' },
-    { name: 'project_number', sql: 'ALTER TABLE memory_journal ADD COLUMN project_number INTEGER' },
-    { name: 'project_owner', sql: 'ALTER TABLE memory_journal ADD COLUMN project_owner TEXT' },
-    { name: 'issue_number', sql: 'ALTER TABLE memory_journal ADD COLUMN issue_number INTEGER' },
-    { name: 'issue_url', sql: 'ALTER TABLE memory_journal ADD COLUMN issue_url TEXT' },
-    { name: 'pr_number', sql: 'ALTER TABLE memory_journal ADD COLUMN pr_number INTEGER' },
-    { name: 'pr_url', sql: 'ALTER TABLE memory_journal ADD COLUMN pr_url TEXT' },
-    { name: 'pr_status', sql: 'ALTER TABLE memory_journal ADD COLUMN pr_status TEXT' },
-    {
-        name: 'workflow_run_id',
-        sql: 'ALTER TABLE memory_journal ADD COLUMN workflow_run_id INTEGER',
-    },
-    { name: 'workflow_name', sql: 'ALTER TABLE memory_journal ADD COLUMN workflow_name TEXT' },
-    { name: 'workflow_status', sql: 'ALTER TABLE memory_journal ADD COLUMN workflow_status TEXT' },
-]
-
-export class NativeConnectionManager implements IDatabaseConnection {
-    private db: Database | null = null
-    private readonly dbPath: string
-    private initialized = false
-
-    constructor(dbPath: string) {
-        this.dbPath = dbPath
-    }
-
-    async initialize(): Promise<void> {
-        if (this.initialized) return
-
-        const dir = path.dirname(this.dbPath)
-        if (dir && !fs.existsSync(dir)) {
-            await fs.promises.mkdir(dir, { recursive: true })
-        }
-
-        try {
-            this.db = new DatabaseAdapter(this.dbPath)
-            const db = this.db
-
-            // Native-only PRAGMAs for performance and safety
-            db.pragma('journal_mode = WAL')
-            db.pragma('synchronous = NORMAL')
-            db.pragma('foreign_keys = ON')
-            db.pragma('temp_store = MEMORY')
-
-            // Load sqlite-vec extension for vector search
-            // Use local `db` ref to avoid race with concurrent close() during await
-            const sqliteVec = await import('sqlite-vec')
-
-            // Guard: if close() was called during the await, abort initialization
-            if (this.db === null) {
-                logger.info('Database closed during initialization, aborting', {
-                    module: 'NativeConnectionManager',
-                })
-                return
-            }
-
-            sqliteVec.load(db)
-            logger.info('sqlite-vec extension loaded', { module: 'NativeConnectionManager' })
-
-            // Create base schema
-            db.exec(SCHEMA_SQL)
-
-            // Create vector embeddings table (sqlite-vec vec0 virtual table)
-            db.exec(`
-                CREATE VIRTUAL TABLE IF NOT EXISTS vec_embeddings USING vec0(
-                    entry_id INTEGER PRIMARY KEY,
-                    embedding float[384]
-                )
-            `)
-
-            // Run schema migrations
-            this.migrateSchema()
-
-            this.initialized = true
-            logger.info('Native database opened', {
-                module: 'NativeConnectionManager',
-                dbPath: this.dbPath,
-            })
-        } catch (error) {
-            logger.error('Failed to initialize native database', {
-                module: 'NativeConnectionManager',
-                error: String(error),
-            })
-            throw new ConnectionError(`Native DB Initialization failed: ${String(error)}`)
-        }
-    }
-
-    private migrateSchema(): void {
-        const db = this.ensureDb()
-
-        // table_info in better-sqlite3 returns an array of objects like { "cid": 0, "name": "id", ...}
-        const tableInfo = db.prepare('PRAGMA table_info(memory_journal)').all() as {
-            name: string
-        }[]
-        const columns = new Set(tableInfo.map((row) => row.name))
-
-        const added: string[] = []
-        for (const col of SHARED_MIGRATION_COLUMNS) {
-            if (!columns.has(col.name)) {
-                db.exec(col.sql)
-                added.push(col.name)
-            }
-        }
-
-        db.prepare('UPDATE tags SET usage_count = 0 WHERE usage_count IS NULL').run()
-
-        // Populate FTS5 index for existing databases that were created before FTS5 was added.
-        // Uses FTS5's built-in 'rebuild' command for content-sync tables.
-        const ftsCount = (
-            db.prepare('SELECT COUNT(*) as c FROM fts_content').get() as { c: number }
-        ).c
-        const entryCount = (
-            db.prepare('SELECT COUNT(*) as c FROM memory_journal').get() as { c: number }
-        ).c
-        if (ftsCount === 0 && entryCount > 0) {
-            db.exec("INSERT INTO fts_content(fts_content) VALUES ('rebuild')")
-            added.push('fts5:populated')
-        } else if (ftsCount > entryCount) {
-            // Ghost entries: FTS has more rows than the journal (hard deletes before the
-            // fts_content_ad trigger existed). Rebuild to remove stale FTS tokens.
-            db.exec("INSERT INTO fts_content(fts_content) VALUES ('rebuild')")
-            added.push('fts5:rebuilt-ghost-cleanup')
-        }
-
-        if (added.length > 0) {
-            logger.info('Schema migrated', {
-                module: 'NativeConnectionManager',
-                dbPath: this.dbPath,
-                changes: added.map((c) => (c.startsWith('fts5:') ? c : `column:${c}`)),
-            })
-        }
-    }
-
-    applyTeamSchema(): void {
-        const db = this.ensureDb()
-        const tableInfo = db.prepare('PRAGMA table_info(memory_journal)').all() as {
-            name: string
-        }[]
-        const columns = new Set(tableInfo.map((row) => row.name))
-
-        // Shared columns + team-only author column
-        const teamColumns: { name: string; sql: string }[] = [
-            ...SHARED_MIGRATION_COLUMNS,
-            { name: 'author', sql: TEAM_SCHEMA_SQL.trim() },
-        ]
-
-        const added: string[] = []
-        for (const col of teamColumns) {
-            if (!columns.has(col.name)) {
-                db.exec(col.sql)
-                added.push(col.name)
-            }
-        }
-
-        if (added.length > 0) {
-            logger.info('Team schema migrated', {
-                module: 'NativeConnectionManager',
-                dbPath: this.dbPath,
-                columnsAdded: added,
-            })
-        }
-    }
-
-    /**
-     * Maps better-sqlite3 results to the legacy `{ columns: string[], values: unknown[][] }[]` shape
-     * Because better-sqlite3 returns arrays of objects instantly, we map them out.
-     */
-    exec(sql: string, params?: unknown[]): QueryResult[] {
-        const db = this.ensureDb()
-
-        // Use pre-compiled regex to detect true mutations that should return an empty set
-        const isMutation = IS_MUTATION_RE.test(sql)
-
-        // For multiple statements separated by semicolon where they just want it to run
-        if (isMutation && sql.includes(';')) {
-            db.exec(sql)
-            return []
-        }
-
-        const stmt = db.prepare(sql)
-
-        if (isMutation || !stmt.reader) {
-            // It's a mutation, don't try to read rows back
-            if (params && params.length > 0) {
-                stmt.run(...params)
-            } else {
-                stmt.run()
-            }
-            return []
-        }
-
-        // It's a SELECT/PRAGMA with a reader
-        const rows =
-            params && params.length > 0
-                ? (stmt.all(...params) as Record<string, unknown>[])
-                : (stmt.all() as Record<string, unknown>[])
-
-        if (rows.length === 0) {
-            return []
-        }
-
-        const columns = Object.keys(rows[0] as object)
-        const values: unknown[][] = rows.map((row) => columns.map((col) => row[col]))
-
-        return [{ columns, values }]
-    }
-
-    /**
-     * Wrapper for INSERT/UPDATE/DELETE
-     */
-    run(sql: string, params?: unknown[]): void {
-        const db = this.ensureDb()
-        if (params && params.length > 0) {
-            db.prepare(sql).run(...params)
-        } else {
-            db.prepare(sql).run()
-        }
-    }
-
-    scheduleSave(): void {
-        // No-op for Native SQLite, disk writes are automatic
-    }
-
-    flushSave(): void {
-        // No-op for Native SQLite
-    }
-
-    close(): void {
-        if (this.db) {
-            // Ensure WAL checkpoint
-            try {
-                this.db.pragma('wal_checkpoint(TRUNCATE)')
-            } catch {
-                // ignore
-            }
-            this.db.close()
-            this.db = null
-        }
-        logger.info('Native database closed', { module: 'NativeConnectionManager' })
-    }
-
-    private ensureDb(): Database {
-        if (!this.db) {
-            throw new ConnectionError('Database not initialized. Call initialize() first.')
-        }
-        return this.db
-    }
-
-    pragma(command: string): void {
-        const db = this.ensureDb()
-        db.pragma(command)
-    }
-
-    getRawDb(): unknown {
-        return this.ensureDb()
-    }
-
-    getDbPath(): string {
-        return this.dbPath
-    }
-
-    getBackupsDir(): string {
-        return path.join(path.dirname(this.dbPath), 'backups')
-    }
-
-    closeDbBeforeRestore(): void {
-        this.close()
-        this.initialized = false
-    }
-
-    setDbAndInitialized(db: unknown): void {
-        this.db = db as Database
-        this.db.pragma('foreign_keys = ON')
-        this.initialized = true
-    }
-}

package/src/database/sqlite-adapter/relationships.ts

@@ -1,70 +0,0 @@
-import type { Database } from 'better-sqlite3'
-import type { Relationship, RelationshipType } from '../../types/index.js'
-import type { NativeConnectionManager } from './native-connection.js'
-import type { EntriesManager } from './entries/index.js'
-
-export class RelationshipsManager {
-    private ctx: NativeConnectionManager
-    private entries: EntriesManager
-
-    constructor(ctx: NativeConnectionManager, entries: EntriesManager) {
-        this.ctx = ctx
-        this.entries = entries
-    }
-
-    private get db(): Database {
-        return this.ctx.getRawDb() as Database
-    }
-
-    linkEntries(
-        fromEntryId: number,
-        toEntryId: number,
-        relationshipType: RelationshipType,
-        description?: string
-    ): Relationship {
-        const db = this.db
-
-        this.entries.getEntryById(fromEntryId)
-        this.entries.getEntryById(toEntryId)
-
-        const result = db
-            .prepare(
-                `INSERT INTO relationships (from_entry_id, to_entry_id, relationship_type, description)
-                 VALUES (?, ?, ?, ?)`
-            )
-            .run(fromEntryId, toEntryId, relationshipType, description ?? null)
-
-        const id = result.lastInsertRowid as number
-
-        this.ctx.scheduleSave()
-
-        return {
-            id,
-            fromEntryId,
-            toEntryId,
-            relationshipType,
-            description: description ?? null,
-            createdAt: new Date().toISOString(),
-        }
-    }
-
-    getRelationships(entryId: number): Relationship[] {
-        const rows = this.db
-            .prepare(
-                `SELECT id, from_entry_id as fromEntryId, to_entry_id as toEntryId,
-                        relationship_type as relationshipType, description, created_at as createdAt
-                 FROM relationships
-                 WHERE from_entry_id = ? OR to_entry_id = ?`
-            )
-            .all(entryId, entryId) as {
-            id: number
-            fromEntryId: number
-            toEntryId: number
-            relationshipType: RelationshipType
-            description: string | null
-            createdAt: string
-        }[]
-
-        return rows
-    }
-}