memory-journal-mcp 6.1.2 → 6.2.1

package/src/database/core/interfaces.ts

@@ -1,188 +0,0 @@
-import type {
-    JournalEntry,
-    Tag,
-    Relationship,
-    EntryType,
-    RelationshipType,
-    ImportanceResult,
-} from '../../types/index.js'
-import type { CreateEntryInput } from './schema.js'
-
-export interface QueryResult {
-    columns: string[]
-    values: unknown[][]
-}
-
-/**
- * Universal SQLite database connection interface.
- * Business logic (EntriesManager, TagsManager) programs against this
- * abstraction rather than the better-sqlite3 driver directly.
- */
-export interface IDatabaseConnection {
-    /**
-     * Executes queries that return results (SELECT, PRAGMA)
-     * Must return the shape: { columns: string[], values: unknown[][] }[]
-     */
-    exec(sql: string, params?: unknown[]): QueryResult[]
-
-    /**
-     * Executes queries that modify data (INSERT, UPDATE, DELETE)
-     */
-    run(sql: string, params?: unknown[]): void
-
-    /**
-     * Prepares and executes startup operations
-     */
-    initialize(): Promise<void>
-
-    /**
-     * Explicit trigger to save database to disk (if applicable)
-     */
-    scheduleSave(): void
-    flushSave(): void
-
-    /**
-     * Closes the database connection safely
-     */
-    close(): void
-
-    /**
-     * Team schema initialization hook
-     */
-    applyTeamSchema(): void
-
-    /**
-     * Directory path access for backups
-     */
-    getBackupsDir(): string
-    getDbPath(): string
-
-    /**
-     * Provides the underlying better-sqlite3 Database instance.
-     * Note: Avoid using this in business logic to prevent driver-coupling
-     */
-    getRawDb(): unknown
-
-    /**
-     * Execute a PRAGMA command.
-     * Wraps the driver-specific pragma call so callers don't need getRawDb().
-     */
-    pragma(command: string): void
-
-    /**
-     * Internal mechanisms for backup/restore
-     */
-    closeDbBeforeRestore(): void
-    setDbAndInitialized(db: unknown): void
-}
-
-/**
- * The public facade representing the capabilities of any memory-journal DB adapter
- */
-export interface IDatabaseAdapter {
-    initialize(): Promise<void>
-    applyTeamSchema(): void
-    flushSave(): void
-    close(): void
-
-    // Entries Manager
-    createEntry(input: CreateEntryInput): JournalEntry
-    getEntryById(id: number): JournalEntry | null
-    getEntryByIdIncludeDeleted(id: number): JournalEntry | null
-    getEntriesByIds(ids: number[]): Map<number, JournalEntry>
-    calculateImportance(entryId: number): ImportanceResult
-    getRecentEntries(limit?: number, isPersonal?: boolean): JournalEntry[]
-    getEntriesPage(offset: number, limit: number): JournalEntry[]
-    getActiveEntryCount(): number
-    updateEntry(
-        id: number,
-        updates: {
-            content?: string
-            entryType?: EntryType
-            tags?: string[]
-            isPersonal?: boolean
-        }
-    ): JournalEntry | null
-    deleteEntry(id: number, permanent?: boolean): boolean
-    searchEntries(
-        query: string,
-        options?: {
-            limit?: number
-            isPersonal?: boolean
-            projectNumber?: number
-            issueNumber?: number
-            prNumber?: number
-            prStatus?: string
-            workflowRunId?: number
-        }
-    ): JournalEntry[]
-    searchByDateRange(
-        startDate: string,
-        endDate: string,
-        options?: {
-            entryType?: EntryType
-            tags?: string[]
-            isPersonal?: boolean
-            projectNumber?: number
-            issueNumber?: number
-            prNumber?: number
-            workflowRunId?: number
-            limit?: number
-        }
-    ): JournalEntry[]
-    getStatistics(
-        groupBy?: 'day' | 'week' | 'month' | 'year',
-        startDate?: string,
-        endDate?: string,
-        projectBreakdown?: boolean
-    ): Record<string, unknown>
-
-    // Tags Manager
-    getTagsForEntry(entryId: number): string[]
-    listTags(): Tag[]
-    mergeTags(
-        sourceTag: string,
-        targetTag: string
-    ): { entriesUpdated: number; sourceDeleted: boolean }
-
-    // Relationships Manager
-    linkEntries(
-        fromEntryId: number,
-        toEntryId: number,
-        relationshipType: RelationshipType,
-        description?: string
-    ): Relationship
-    getRelationships(entryId: number): Relationship[]
-
-    // Backup Manager
-    getBackupsDir(): string
-    exportToFile(
-        backupName?: string
-    ): Promise<{ filename: string; path: string; sizeBytes: number }>
-    listBackups(): { filename: string; path: string; sizeBytes: number; createdAt: string }[]
-    deleteOldBackups(keepCount: number): { deleted: string[]; kept: number }
-    restoreFromFile(filename: string): Promise<{
-        restoredFrom: string
-        previousEntryCount: number
-        newEntryCount: number
-    }>
-    getHealthStatus(): {
-        database: {
-            path: string
-            sizeBytes: number
-            entryCount: number
-            deletedEntryCount: number
-            relationshipCount: number
-            tagCount: number
-        }
-        backups: {
-            directory: string
-            count: number
-            lastBackup: { filename: string; createdAt: string; sizeBytes: number } | null
-        }
-    }
-
-    getRawDb(): unknown
-    pragma(command: string): void
-    executeRawQuery(sql: string, params?: unknown[]): QueryResult[]
-}

package/src/database/core/schema.ts

@@ -1,152 +0,0 @@
-/**
- * Memory Journal MCP Server - Database Schema
- *
- * SQL DDL for initialization and input types for the database adapter.
- */
-
-import type { EntryType, SignificanceType } from '../../types/index.js'
-
-/**
- * SQL schema for database initialization.
- * Creates all tables and indexes if they don't already exist.
- */
-export 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
-);
-
--- Legacy embeddings table (active embeddings use sqlite-vec vec0 virtual table)
-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);
-
--- Composite covering index for getRecentEntries (WHERE deleted_at IS NULL ORDER BY timestamp DESC, id DESC)
-CREATE INDEX IF NOT EXISTS idx_memory_journal_recent ON memory_journal(deleted_at, timestamp DESC, id DESC);
-
--- FTS5 full-text search index (content-sync: reads from source table, no duplicate storage)
-CREATE VIRTUAL TABLE IF NOT EXISTS fts_content USING fts5(
-    content,
-    content=memory_journal,
-    content_rowid=id,
-    tokenize='porter unicode61'
-);
-
--- Triggers to keep FTS5 index in sync with memory_journal
-CREATE TRIGGER IF NOT EXISTS fts_content_ai AFTER INSERT ON memory_journal BEGIN
-    INSERT INTO fts_content(rowid, content) VALUES (new.id, new.content);
-END;
-
-CREATE TRIGGER IF NOT EXISTS fts_content_au AFTER UPDATE OF content ON memory_journal BEGIN
-    INSERT INTO fts_content(fts_content, rowid, content) VALUES ('delete', old.id, old.content);
-    INSERT INTO fts_content(rowid, content) VALUES (new.id, new.content);
-END;
-
-CREATE TRIGGER IF NOT EXISTS fts_content_ad AFTER DELETE ON memory_journal BEGIN
-    INSERT INTO fts_content(fts_content, rowid, content) VALUES ('delete', old.id, old.content);
-END;
-`
-
-/**
- * Input for creating a new entry
- */
-export interface CreateEntryInput {
-    content: string
-    entryType?: EntryType
-    tags?: string[]
-    isPersonal?: boolean
-    significanceType?: SignificanceType
-    autoContext?: string
-    /** Optional ISO 8601 timestamp override (defaults to current time) */
-    timestamp?: string
-    projectNumber?: number
-    projectOwner?: string
-    issueNumber?: number
-    issueUrl?: string
-    prNumber?: number
-    prUrl?: string
-    prStatus?: 'draft' | 'open' | 'merged' | 'closed'
-    workflowRunId?: number
-    workflowName?: string
-    workflowStatus?: 'queued' | 'in_progress' | 'completed'
-}
-
-/**
- * SQL migration to add the author column for team databases.
- * Applied after SCHEMA_SQL when initializing a team database.
- */
-export const TEAM_SCHEMA_SQL = `
--- Author column for team entries (identifies who shared the entry)
-ALTER TABLE memory_journal ADD COLUMN author TEXT;
-`
-
-/**
- * Input for creating a team entry (extends standard entry with author)
- */
-export interface CreateTeamEntryInput extends CreateEntryInput {
-    /** Author name (auto-detected from git config or TEAM_AUTHOR env) */
-    author?: string
-}

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

@@ -1,167 +0,0 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-import { logger } from '../../utils/logger.js'
-import { assertNoPathTraversal } from '../../utils/security-utils.js'
-import { ResourceNotFoundError, ValidationError } from '../../types/errors.js'
-import type { IDatabaseConnection } from '../core/interfaces.js'
-
-/** Maximum length for user-supplied backup names after sanitization */
-const MAX_BACKUP_NAME_LENGTH = 50
-
-export class BackupManager {
-    constructor(private ctx: IDatabaseConnection) {}
-
-    async exportToFile(
-        backupName?: string
-    ): Promise<{ filename: string; path: string; sizeBytes: number }> {
-        const backupsDir = this.ctx.getBackupsDir()
-
-        if (backupName) {
-            assertNoPathTraversal(backupName)
-        }
-
-        if (!fs.existsSync(backupsDir)) {
-            await fs.promises.mkdir(backupsDir, { recursive: true })
-        }
-
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
-        const sanitizedName = backupName
-            ? backupName.replace(/[/\\:*?"<>|]/g, '_').slice(0, MAX_BACKUP_NAME_LENGTH)
-            : `backup_${timestamp}`
-        const filename = `${sanitizedName}.db`
-        const backupPath = path.join(backupsDir, filename)
-
-        try {
-            this.ctx.pragma('wal_checkpoint(TRUNCATE)')
-        } catch (checkpointErr) {
-            logger.debug('WAL checkpoint skipped', {
-                module: 'SqliteAdapter',
-                operation: 'exportToFile',
-                error:
-                    checkpointErr instanceof Error ? checkpointErr.message : String(checkpointErr),
-            })
-        }
-        await fs.promises.copyFile(this.ctx.getDbPath(), backupPath)
-
-        const stats = await fs.promises.stat(backupPath)
-
-        logger.info('Backup created', {
-            module: 'SqliteAdapter',
-            operation: 'exportToFile',
-            context: { backupPath, sizeBytes: stats.size },
-        })
-
-        return { filename, path: backupPath, sizeBytes: stats.size }
-    }
-
-    listBackups(): { filename: string; path: string; sizeBytes: number; createdAt: string }[] {
-        const backupsDir = this.ctx.getBackupsDir()
-
-        if (!fs.existsSync(backupsDir)) {
-            return []
-        }
-
-        const files = fs.readdirSync(backupsDir)
-        const backups: { filename: string; path: string; sizeBytes: number; createdAt: string }[] =
-            []
-
-        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
-            }
-        }
-
-        backups.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
-        return backups
-    }
-
-    deleteOldBackups(keepCount: number): { deleted: string[]; kept: number } {
-        const backups = this.listBackups()
-
-        if (keepCount < 1 || Number.isNaN(keepCount)) {
-            throw new ValidationError('keepCount must be at least 1')
-        }
-
-        const toKeep = backups.slice(0, keepCount)
-        const toDelete = backups.slice(keepCount)
-        const deleted: string[] = []
-
-        for (const backup of toDelete) {
-            try {
-                fs.unlinkSync(backup.path)
-                deleted.push(backup.filename)
-            } catch {
-                // Skip files that can't be deleted
-            }
-        }
-
-        logger.info('Old backups cleaned up', {
-            module: 'SqliteAdapter',
-            operation: 'deleteOldBackups',
-            context: { kept: toKeep.length, deleted: deleted.length },
-        })
-
-        return { deleted, kept: toKeep.length }
-    }
-
-    async restoreFromFile(filename: string): Promise<{
-        restoredFrom: string
-        previousEntryCount: number
-        newEntryCount: number
-    }> {
-        assertNoPathTraversal(filename)
-
-        const backupsDir = this.ctx.getBackupsDir()
-        const backupPath = path.join(backupsDir, filename)
-
-        if (!fs.existsSync(backupPath)) {
-            throw new ResourceNotFoundError('Backup', filename)
-        }
-
-        const currentCountResult = this.ctx.exec(
-            'SELECT COUNT(*) FROM memory_journal WHERE deleted_at IS NULL'
-        )
-        const previousEntryCount = (currentCountResult[0]?.values[0]?.[0] as number) ?? 0
-
-        await this.exportToFile(`pre_restore_${new Date().toISOString().replace(/[:.]/g, '-')}`)
-
-        // Close old DB via manager
-        this.ctx.closeDbBeforeRestore()
-
-        // Native better-sqlite3 connection
-        await fs.promises.copyFile(backupPath, this.ctx.getDbPath())
-
-        // Re-initialize the native connection via dynamic import to avoid static dependency
-        const DatabaseAdapter = (await import('better-sqlite3').then((m) => m.default)) as new (
-            path: string
-        ) => unknown
-        const newDb = new DatabaseAdapter(this.ctx.getDbPath())
-        this.ctx.setDbAndInitialized(newDb)
-
-        const newCountResult = this.ctx.exec(
-            'SELECT COUNT(*) FROM memory_journal WHERE deleted_at IS NULL'
-        )
-        const newEntryCount = (newCountResult[0]?.values[0]?.[0] as number) ?? 0
-
-        logger.info('Database restored from backup', {
-            module: 'SqliteAdapter',
-            operation: 'restoreFromFile',
-            context: { backupPath, previousEntryCount, newEntryCount },
-        })
-
-        return { restoredFrom: filename, previousEntryCount, newEntryCount }
-    }
-}