memory-journal-mcp 6.1.2 → 6.2.1

package/src/database/sqlite-adapter/entries/crud.ts

@@ -1,233 +0,0 @@
-import type { JournalEntry, EntryType } from '../../../types/index.js'
-import type { CreateEntryInput } from '../../core/schema.js'
-import { ENTRY_COLUMNS, type EntriesSharedContext, rowToEntry, rowToObject } from './shared.js'
-
-export function createEntry(context: EntriesSharedContext, input: CreateEntryInput): JournalEntry {
-    const { db, tagsMgr } = context
-
-    let timestamp = input.timestamp ?? new Date().toISOString()
-    // SQLite expects standard ISO format
-    if (!timestamp.includes('T')) {
-        timestamp += 'T00:00:00.000Z'
-    }
-
-    let insertId!: number
-    const txn = db.transaction(() => {
-        // Insert main entry
-        const stmt = db.prepare(
-            `
-            INSERT INTO memory_journal (
-                entry_type, content, timestamp, 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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            `
-        )
-        const result = stmt.run(
-            input.entryType ?? 'personal_reflection',
-            input.content,
-            timestamp,
-            (input.isPersonal ?? true) ? 1 : 0,
-            input.significanceType || null,
-            input.autoContext ? 1 : 0,
-            input.projectNumber ?? null,
-            input.projectOwner || null,
-            input.issueNumber ?? null,
-            input.issueUrl || null,
-            input.prNumber ?? null,
-            input.prUrl || null,
-            input.prStatus || null,
-            input.workflowRunId ?? null,
-            input.workflowName || null,
-            input.workflowStatus || null
-        )
-        insertId = result.lastInsertRowid as number
-
-        // Link tags
-        if (input.tags && input.tags.length > 0) {
-            tagsMgr.linkTagsToEntry(insertId, input.tags)
-        }
-    })
-
-    txn()
-
-    const entry = getEntryById(context, insertId)
-    if (!entry) {
-        throw new Error(`Failed to retrieve newly created entry ${insertId}`)
-    }
-    return entry
-}
-
-export function getEntryById(context: EntriesSharedContext, id: number): JournalEntry | null {
-    const { db, tagsMgr } = context
-    const stmt = db.prepare(
-        `SELECT ${ENTRY_COLUMNS} FROM memory_journal WHERE id = ? AND deleted_at IS NULL`
-    )
-    const row = rowToObject(stmt.get(id))
-
-    if (!row) {
-        return null
-    }
-
-    return rowToEntry(tagsMgr, row)
-}
-
-export function getEntriesByIds(
-    context: EntriesSharedContext,
-    ids: number[]
-): Map<number, JournalEntry> {
-    const result = new Map<number, JournalEntry>()
-    if (ids.length === 0) return result
-
-    const { db, tagsMgr } = context
-    const placeholders = ids.map(() => '?').join(', ')
-    const stmt = db.prepare(
-        `SELECT ${ENTRY_COLUMNS} FROM memory_journal WHERE id IN (${placeholders}) AND deleted_at IS NULL`
-    )
-    const rows = stmt.all(ids)
-
-    if (rows.length === 0) return result
-
-    const entries = rows.map((r) => {
-        const p = r as Partial<JournalEntry>
-        return {
-            ...p,
-            isPersonal: Boolean(p.isPersonal),
-            tags: [],
-        } as JournalEntry
-    })
-
-    const entryIds = entries.map((e) => e.id)
-    const tagsMap = tagsMgr.batchGetTagsForEntries(entryIds)
-
-    for (const entry of entries) {
-        entry.tags = tagsMap.get(entry.id) ?? []
-        result.set(entry.id, entry)
-    }
-
-    return result
-}
-
-export function getEntryByIdIncludeDeleted(
-    context: EntriesSharedContext,
-    id: number
-): JournalEntry | null {
-    const { db, tagsMgr } = context
-    const stmt = db.prepare(`SELECT ${ENTRY_COLUMNS} FROM memory_journal WHERE id = ?`)
-    const row = rowToObject(stmt.get(id))
-
-    if (!row) {
-        return null
-    }
-
-    return rowToEntry(tagsMgr, row)
-}
-
-export function getActiveEntryCount(context: EntriesSharedContext): number {
-    const { db } = context
-    const stmt = db.prepare('SELECT COUNT(*) as count FROM memory_journal WHERE deleted_at IS NULL')
-    const row = rowToObject(stmt.get())
-    return (row?.['count'] as number) || 0
-}
-
-export function updateEntry(
-    context: EntriesSharedContext,
-    id: number,
-    input: {
-        content?: string
-        entryType?: EntryType
-        tags?: string[]
-        isPersonal?: boolean
-        significanceType?: string
-        autoContext?: boolean
-        projectNumber?: number
-        projectOwner?: string
-        issueNumber?: number
-        issueUrl?: string
-        prNumber?: number
-        prUrl?: string
-        prStatus?: string
-        workflowRunId?: number
-        workflowName?: string
-        workflowStatus?: string
-    }
-): JournalEntry | null {
-    const { db, tagsMgr } = context
-
-    // Check existence first
-    const existing = getEntryById(context, id)
-    if (!existing) return null
-
-    const updates: string[] = []
-    const values: unknown[] = []
-
-    if (input.entryType !== undefined) {
-        updates.push('entry_type = ?')
-        values.push(input.entryType)
-    }
-    if (input.content !== undefined) {
-        updates.push('content = ?')
-        values.push(input.content)
-    }
-    if (input.isPersonal !== undefined) {
-        updates.push('is_personal = ?')
-        values.push(input.isPersonal ? 1 : 0)
-    }
-    if (input.significanceType !== undefined) {
-        updates.push('significance_type = ?')
-        values.push(input.significanceType)
-    }
-    if (input.autoContext !== undefined) {
-        updates.push('auto_context = ?')
-        values.push(input.autoContext ? 1 : 0)
-    }
-    // GitHub extensions
-    for (const key of [
-        'projectNumber',
-        'projectOwner',
-        'issueNumber',
-        'issueUrl',
-        'prNumber',
-        'prUrl',
-        'prStatus',
-        'workflowRunId',
-        'workflowName',
-        'workflowStatus',
-    ] as const) {
-        if (input[key] !== undefined) {
-            const snakeKey = key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
-            updates.push(`${snakeKey} = ?`)
-            values.push(input[key] ?? null)
-        }
-    }
-
-    if (updates.length > 0) {
-        const query = `UPDATE memory_journal SET ${updates.join(', ')} WHERE id = ? AND deleted_at IS NULL`
-        const stmt = db.prepare(query)
-        const result = stmt.run(...values, id)
-        if (result.changes === 0) return null
-    }
-
-    if (input.tags !== undefined) {
-        db.prepare('DELETE FROM entry_tags WHERE entry_id = ?').run(id)
-        tagsMgr.linkTagsToEntry(id, input.tags)
-    }
-
-    return getEntryById(context, id)
-}
-
-export function deleteEntry(context: EntriesSharedContext, id: number, permanent = false): boolean {
-    const { db } = context
-
-    if (permanent) {
-        const stmt = db.prepare('DELETE FROM memory_journal WHERE id = ?')
-        const result = stmt.run(id)
-        return result.changes > 0
-    }
-
-    const stmt = db.prepare(
-        `UPDATE memory_journal SET deleted_at = ? WHERE id = ? AND deleted_at IS NULL`
-    )
-    const result = stmt.run(new Date().toISOString(), id)
-    return result.changes > 0
-}

package/src/database/sqlite-adapter/entries/importance.ts

@@ -1,76 +0,0 @@
-import type { ImportanceBreakdown, ImportanceResult } from '../../../types/index.js'
-import { type EntriesSharedContext, rowToObject } from './shared.js'
-
-const IMPORTANCE_WEIGHTS = {
-    significance: 0.3,
-    relationships: 0.35,
-    causal: 0.2,
-    recency: 0.15,
-} as const
-
-/** Relationship count at which the relationships component reaches its maximum score (1.0) */
-const MAX_RELATIONSHIP_SCORE_AT = 5
-/** Causal relationship count at which the causal component reaches its maximum score (1.0) */
-const MAX_CAUSAL_SCORE_AT = 3
-/** Number of days after which the recency component decays to zero */
-const RECENCY_WINDOW_DAYS = 90
-
-export function calculateImportance(
-    context: EntriesSharedContext,
-    entryId: number
-): ImportanceResult {
-    const { db } = context
-    const round2 = (n: number): number => Math.round(n * 100) / 100
-
-    const stmt = db.prepare(`SELECT
-        m.significance_type as significanceType,
-        m.timestamp,
-        (SELECT COUNT(*) FROM relationships
-         WHERE from_entry_id = ? OR to_entry_id = ?) AS rel_count,
-        (SELECT COUNT(*) FROM relationships
-         WHERE (from_entry_id = ? OR to_entry_id = ?)
-         AND relationship_type IN ('blocked_by', 'resolved', 'caused')) AS causal_count
-    FROM memory_journal m
-    WHERE m.id = ? AND m.deleted_at IS NULL`)
-
-    const row = rowToObject(stmt.get(entryId, entryId, entryId, entryId, entryId))
-
-    if (!row) {
-        return {
-            score: 0,
-            breakdown: { significance: 0, relationships: 0, causal: 0, recency: 0 },
-        }
-    }
-
-    const significanceType = row['significanceType'] as string | null
-    const timestamp = row['timestamp'] as string
-    const relCount = (row['rel_count'] as number) ?? 0
-    const causalCount = (row['causal_count'] as number) ?? 0
-
-    const significanceRaw = significanceType ? 1.0 : 0.0
-    const relationshipsRaw = Math.min(relCount / MAX_RELATIONSHIP_SCORE_AT, 1.0)
-    const causalRaw = Math.min(causalCount / MAX_CAUSAL_SCORE_AT, 1.0)
-
-    const entryDate = new Date(timestamp)
-    const now = new Date()
-    const daysSince = Math.floor((now.getTime() - entryDate.getTime()) / (1000 * 60 * 60 * 24))
-    const recencyRaw = Math.max(0, 1 - daysSince / RECENCY_WINDOW_DAYS)
-
-    const w = IMPORTANCE_WEIGHTS
-
-    const breakdown: ImportanceBreakdown = {
-        significance: round2(significanceRaw * w.significance),
-        relationships: round2(relationshipsRaw * w.relationships),
-        causal: round2(causalRaw * w.causal),
-        recency: round2(recencyRaw * w.recency),
-    }
-
-    const score = round2(
-        significanceRaw * w.significance +
-            relationshipsRaw * w.relationships +
-            causalRaw * w.causal +
-            recencyRaw * w.recency
-    )
-
-    return { score, breakdown }
-}

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

@@ -1,142 +0,0 @@
-import type { JournalEntry, EntryType, ImportanceResult } from '../../../types/index.js'
-import type { CreateEntryInput } from '../../core/schema.js'
-import type { Database } from 'better-sqlite3'
-import type { NativeConnectionManager } from '../native-connection.js'
-import type { TagsManager } from '../tags.js'
-
-import type { EntriesSharedContext } from './shared.js'
-import {
-    createEntry,
-    getEntryById,
-    getEntriesByIds,
-    getEntryByIdIncludeDeleted,
-    getActiveEntryCount,
-    updateEntry,
-    deleteEntry,
-} from './crud.js'
-import {
-    getRecentEntries as getRecentEntriesQuery,
-    getEntriesPage,
-    searchEntries,
-    searchByDateRange,
-} from './search.js'
-import { calculateImportance } from './importance.js'
-import { getStatistics } from './statistics.js'
-
-export class EntriesManager {
-    private sharedContext: EntriesSharedContext
-
-    constructor(ctx: NativeConnectionManager, tagsMgr: TagsManager) {
-        this.sharedContext = {
-            ctx,
-            tagsMgr,
-            get db() {
-                return ctx.getRawDb() as Database
-            },
-        }
-    }
-
-    createEntry(input: CreateEntryInput): JournalEntry {
-        return createEntry(this.sharedContext, input)
-    }
-
-    getEntryById(id: number): JournalEntry | null {
-        return getEntryById(this.sharedContext, id)
-    }
-
-    getEntriesByIds(ids: number[]): Map<number, JournalEntry> {
-        return getEntriesByIds(this.sharedContext, ids)
-    }
-
-    getEntryByIdIncludeDeleted(id: number): JournalEntry | null {
-        return getEntryByIdIncludeDeleted(this.sharedContext, id)
-    }
-
-    getActiveEntryCount(): number {
-        return getActiveEntryCount(this.sharedContext)
-    }
-
-    updateEntry(
-        id: number,
-        input: {
-            content?: string
-            entryType?: EntryType
-            tags?: string[]
-            isPersonal?: boolean
-            significanceType?: string
-            autoContext?: boolean
-            projectNumber?: number
-            projectOwner?: string
-            issueNumber?: number
-            issueUrl?: string
-            prNumber?: number
-            prUrl?: string
-            prStatus?: string
-            workflowRunId?: number
-            workflowName?: string
-            workflowStatus?: string
-        }
-    ): JournalEntry | null {
-        return updateEntry(this.sharedContext, id, input)
-    }
-
-    deleteEntry(id: number, permanent = false): boolean {
-        return deleteEntry(this.sharedContext, id, permanent)
-    }
-
-    getRecentEntries(limit = 10, isPersonal?: boolean): JournalEntry[] {
-        if (isPersonal !== undefined) {
-            return searchEntries(this.sharedContext, '', { limit, isPersonal })
-        }
-        return getRecentEntriesQuery(this.sharedContext, limit)
-    }
-
-    getEntriesPage(offset: number, limit: number, order: 'asc' | 'desc' = 'desc'): JournalEntry[] {
-        return getEntriesPage(this.sharedContext, offset, limit, order)
-    }
-
-    searchEntries(
-        queryStr: string,
-        options?: {
-            limit?: number
-            isPersonal?: boolean
-            projectNumber?: number
-            issueNumber?: number
-            prNumber?: number
-            prStatus?: string
-            workflowRunId?: number
-        }
-    ): JournalEntry[] {
-        return searchEntries(this.sharedContext, queryStr, 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 searchByDateRange(this.sharedContext, startDate, endDate, options)
-    }
-
-    calculateImportance(entryId: number): ImportanceResult {
-        return calculateImportance(this.sharedContext, entryId)
-    }
-
-    getStatistics(
-        timeframe: 'day' | 'week' | 'month' | 'year' = 'month',
-        startDate?: string,
-        endDate?: string,
-        projectBreakdown?: boolean
-    ): Record<string, unknown> {
-        return getStatistics(this.sharedContext, timeframe, startDate, endDate, projectBreakdown)
-    }
-}