memory-journal-mcp 6.1.2 → 6.2.1

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

@@ -1,182 +0,0 @@
-import type { Database } from 'better-sqlite3'
-import { logger } from '../../utils/logger.js'
-import { ResourceNotFoundError, QueryError } from '../../types/errors.js'
-import type { Tag } from '../../types/index.js'
-import type { NativeConnectionManager } from './native-connection.js'
-
-export class TagsManager {
-    private ctx: NativeConnectionManager
-
-    constructor(ctx: NativeConnectionManager) {
-        this.ctx = ctx
-    }
-
-    private get db(): Database {
-        return this.ctx.getRawDb() as Database
-    }
-
-    linkTagsToEntry(entryId: number, tagNames: string[]): void {
-        if (tagNames.length === 0) return
-        const db = this.db
-
-        const insertPlaceholders = tagNames.map(() => '(?, 0)').join(', ')
-        db.prepare(
-            `INSERT OR IGNORE INTO tags (name, usage_count) VALUES ${insertPlaceholders}`
-        ).run(...tagNames)
-
-        const selectPlaceholders = tagNames.map(() => '?').join(', ')
-        const rows = db
-            .prepare(`SELECT id, name FROM tags WHERE name IN (${selectPlaceholders})`)
-            .all(...tagNames) as { id: number; name: string }[]
-
-        const tagIds = rows.map((r) => r.id)
-        if (tagIds.length === 0) return
-
-        const linkPlaceholders = tagIds.map(() => '(?, ?)').join(', ')
-        const linkParams = tagIds.flatMap((tagId) => [entryId, tagId])
-        db.prepare(
-            `INSERT OR IGNORE INTO entry_tags (entry_id, tag_id) VALUES ${linkPlaceholders}`
-        ).run(...linkParams)
-
-        const updatePlaceholders = tagIds.map(() => '?').join(', ')
-        db.prepare(
-            `UPDATE tags
-             SET usage_count = (
-                 SELECT COUNT(*)
-                 FROM entry_tags et
-                 WHERE et.tag_id = tags.id
-             )
-             WHERE id IN (${updatePlaceholders})`
-        ).run(...tagIds)
-    }
-
-    getTagsForEntry(entryId: number): string[] {
-        const rows = this.db
-            .prepare(
-                `SELECT t.name FROM tags t
-                 JOIN entry_tags et ON t.id = et.tag_id
-                 WHERE et.entry_id = ?`
-            )
-            .all(entryId) as { name: string }[]
-
-        return rows.map((r) => r.name)
-    }
-
-    batchGetTagsForEntries(ids: number[]): Map<number, string[]> {
-        const tagMap = new Map<number, string[]>()
-        if (ids.length === 0) return tagMap
-
-        const placeholders = ids.map(() => '?').join(', ')
-        const rows = this.db
-            .prepare(
-                `SELECT et.entry_id, t.name
-                 FROM entry_tags et
-                 JOIN tags t ON et.tag_id = t.id
-                 WHERE et.entry_id IN (${placeholders})`
-            )
-            .all(...ids) as { entry_id: number; name: string }[]
-
-        for (const row of rows) {
-            const existing = tagMap.get(row.entry_id)
-            if (existing) {
-                existing.push(row.name)
-            } else {
-                tagMap.set(row.entry_id, [row.name])
-            }
-        }
-        return tagMap
-    }
-
-    listTags(): Tag[] {
-        const rows = this.db
-            .prepare(
-                'SELECT id, name, COALESCE(usage_count, 0) as usage_count FROM tags WHERE COALESCE(usage_count, 0) > 0 ORDER BY usage_count DESC'
-            )
-            .all() as { id: number; name: string; usage_count: number }[]
-
-        return rows.map((r) => ({ id: r.id, name: r.name, usageCount: r.usage_count }))
-    }
-
-    mergeTags(
-        sourceTag: string,
-        targetTag: string
-    ): { entriesUpdated: number; sourceDeleted: boolean } {
-        const db = this.db
-
-        const mergeOp = db.transaction(() => {
-            const sourceRow = db.prepare('SELECT id FROM tags WHERE name = ?').get(sourceTag) as
-                | { id: number }
-                | undefined
-            if (!sourceRow) throw new ResourceNotFoundError('Tag', sourceTag)
-            const sourceTagId = sourceRow.id
-
-            db.prepare('INSERT OR IGNORE INTO tags (name, usage_count) VALUES (?, 0)').run(
-                targetTag
-            )
-            const targetRow = db.prepare('SELECT id FROM tags WHERE name = ?').get(targetTag) as
-                | { id: number }
-                | undefined
-            if (!targetRow) throw new QueryError(`Failed to get or create target tag: ${targetTag}`)
-            const targetTagId = targetRow.id
-
-            // Clean orphaned entry_tags (entries permanently deleted but links remain)
-            db.prepare(
-                `DELETE FROM entry_tags WHERE tag_id = ? AND entry_id NOT IN (SELECT id FROM memory_journal)`
-            ).run(sourceTagId)
-            db.prepare(
-                `DELETE FROM entry_tags WHERE tag_id = ? AND entry_id NOT IN (SELECT id FROM memory_journal)`
-            ).run(targetTagId)
-
-            // Select only valid entries (join ensures no orphans)
-            const entryRows = db
-                .prepare(
-                    `SELECT et.entry_id FROM entry_tags et
-                     JOIN memory_journal mj ON et.entry_id = mj.id
-                     WHERE et.tag_id = ?`
-                )
-                .all(sourceTagId) as { entry_id: number }[]
-            const entryIds = entryRows.map((r) => r.entry_id)
-
-            // Pre-fetch entries already linked to targetTag in one query (O(1) vs O(N))
-            const existingRows = db
-                .prepare('SELECT entry_id FROM entry_tags WHERE tag_id = ?')
-                .all(targetTagId) as { entry_id: number }[]
-            const existingEntryIds = new Set(existingRows.map((r) => r.entry_id))
-
-            // Filter to only entries that need linking
-            const newEntryIds = entryIds.filter((id) => !existingEntryIds.has(id))
-            const entriesUpdated = newEntryIds.length
-
-            if (newEntryIds.length > 0) {
-                const placeholders = newEntryIds.map(() => '(?, ?)').join(', ')
-                const params = newEntryIds.flatMap((entryId) => [entryId, targetTagId])
-                db.prepare(
-                    `INSERT OR IGNORE INTO entry_tags (entry_id, tag_id) VALUES ${placeholders}`
-                ).run(...params)
-            }
-
-            if (entriesUpdated > 0) {
-                db.prepare('UPDATE tags SET usage_count = usage_count + ? WHERE id = ?').run(
-                    entriesUpdated,
-                    targetTagId
-                )
-            }
-
-            db.prepare('DELETE FROM entry_tags WHERE tag_id = ?').run(sourceTagId)
-            db.prepare('DELETE FROM tags WHERE id = ?').run(sourceTagId)
-
-            return { entriesUpdated, sourceDeleted: true }
-        })
-
-        const result = mergeOp()
-
-        this.ctx.scheduleSave()
-        logger.info('Tags merged', {
-            module: 'SqliteAdapter',
-            operation: 'mergeTags',
-            context: { sourceTag, targetTag, entriesUpdated: result.entriesUpdated },
-        })
-
-        return result
-    }
-}

package/src/filtering/tool-filter.ts

@@ -1,312 +0,0 @@
-/**
- * Memory Journal MCP Server - Tool Filtering
- *
- * Configurable tool filtering system with groups and meta-groups.
- * Matches mysql-mcp filtering syntax and patterns.
- */
-
-import type { ToolGroup, MetaGroup, ToolFilterRule, ToolFilterConfig } from '../types/index.js'
-
-// Re-export ToolFilterConfig from types
-export type { ToolFilterConfig } from '../types/index.js'
-
-/**
- * Tool group definitions mapping group names to tool names
- *
- * All 61 tools are categorized here for filtering support.
- */
-export const TOOL_GROUPS: Record<ToolGroup, string[]> = {
-    core: [
-        'create_entry',
-        'get_entry_by_id',
-        'get_recent_entries',
-        'create_entry_minimal',
-        'test_simple',
-        'list_tags',
-    ],
-    search: ['search_entries', 'search_by_date_range', 'semantic_search', 'get_vector_index_stats'],
-    analytics: ['get_statistics', 'get_cross_project_insights'],
-    relationships: ['link_entries', 'visualize_relationships'],
-    export: ['export_entries'],
-    admin: [
-        'update_entry',
-        'delete_entry',
-        'rebuild_vector_index',
-        'add_to_vector_index',
-        'merge_tags',
-    ],
-    github: [
-        'get_github_issues',
-        'get_github_prs',
-        'get_github_issue',
-        'get_github_pr',
-        'get_github_context',
-        'get_kanban_board',
-        'move_kanban_item',
-        'create_github_issue_with_entry',
-        'close_github_issue_with_entry',
-        'get_github_milestones',
-        'get_github_milestone',
-        'create_github_milestone',
-        'update_github_milestone',
-        'delete_github_milestone',
-        'get_repo_insights',
-        'get_copilot_reviews',
-    ],
-    backup: ['backup_journal', 'list_backups', 'restore_backup', 'cleanup_backups'],
-    team: [
-        'team_create_entry',
-        'team_get_entry_by_id',
-        'team_get_recent',
-        'team_list_tags',
-        'team_search',
-        'team_search_by_date_range',
-        'team_update_entry',
-        'team_delete_entry',
-        'team_merge_tags',
-        'team_get_statistics',
-        'team_link_entries',
-        'team_visualize_relationships',
-        'team_export_entries',
-        'team_backup',
-        'team_list_backups',
-        'team_semantic_search',
-        'team_get_vector_index_stats',
-        'team_rebuild_vector_index',
-        'team_add_to_vector_index',
-        'team_get_cross_project_insights',
-    ],
-    codemode: ['mj_execute_code'],
-}
-
-/**
- * Meta-group definitions mapping shortcuts to groups
- */
-export const META_GROUPS: Record<MetaGroup, ToolGroup[]> = {
-    starter: ['core', 'search', 'codemode'],
-    essential: ['core', 'codemode'],
-    full: [
-        'core',
-        'search',
-        'analytics',
-        'relationships',
-        'export',
-        'admin',
-        'github',
-        'backup',
-        'team',
-        'codemode',
-    ],
-    readonly: ['core', 'search', 'analytics', 'relationships', 'export'],
-}
-
-/**
- * Get all tool names across all groups
- */
-export function getAllToolNames(): string[] {
-    const allTools: string[] = []
-    for (const tools of Object.values(TOOL_GROUPS)) {
-        allTools.push(...tools)
-    }
-    return allTools
-}
-
-/**
- * Get the group for a specific tool
- */
-export function getToolGroup(toolName: string): ToolGroup | undefined {
-    for (const [group, tools] of Object.entries(TOOL_GROUPS)) {
-        if (tools.includes(toolName)) {
-            return group as ToolGroup
-        }
-    }
-    return undefined
-}
-
-/**
- * Determine which tool groups have at least one enabled tool.
- * Used by instruction generation to conditionally include/exclude sections.
- */
-export function getEnabledGroups(enabledTools: Set<string>): Set<ToolGroup> {
-    const groups = new Set<ToolGroup>()
-    for (const [group, tools] of Object.entries(TOOL_GROUPS) as [ToolGroup, string[]][]) {
-        if (tools.some((t) => enabledTools.has(t))) {
-            groups.add(group)
-        }
-    }
-    return groups
-}
-
-/**
- * Check if a string is a valid group name
- */
-function isGroup(name: string): name is ToolGroup {
-    return name in TOOL_GROUPS
-}
-
-/**
- * Check if a string is a valid meta-group name
- */
-function isMetaGroup(name: string): name is MetaGroup {
-    return name in META_GROUPS
-}
-
-/**
- * Parse a tool filter string into configuration
- *
- * Syntax:
- * - `starter` - Use starter preset (whitelist mode)
- * - `core,search` - Enable specific groups (whitelist mode)
- * - `full,-admin` - All tools except admin group
- * - `starter,-delete_entry` - Starter without specific tool
- * - `+semantic_search` - Add specific tool to current set
- */
-export function parseToolFilter(filterString: string): ToolFilterConfig {
-    const rules: ToolFilterRule[] = []
-    const parts = filterString
-        .split(',')
-        .map((p) => p.trim())
-        .filter(Boolean)
-
-    // Determine if we're in whitelist or blacklist mode
-    // If first item has no prefix and is a group/metagroup, we're in whitelist mode
-    let enabledTools = new Set<string>()
-    let isWhitelistMode = false
-
-    for (let i = 0; i < parts.length; i++) {
-        const part = parts[i]
-        if (!part) continue
-
-        const isAdd = part.startsWith('+')
-        const isRemove = part.startsWith('-')
-        const name = isAdd || isRemove ? part.slice(1) : part
-
-        if (i === 0 && !isAdd && !isRemove) {
-            // First item without prefix - whitelist mode
-            isWhitelistMode = true
-
-            if (isMetaGroup(name)) {
-                // Expand meta-group to groups
-                for (const group of META_GROUPS[name]) {
-                    enabledTools = new Set([...enabledTools, ...TOOL_GROUPS[group]])
-                }
-            } else if (isGroup(name)) {
-                enabledTools = new Set([...enabledTools, ...TOOL_GROUPS[name]])
-            } else {
-                // Single tool
-                enabledTools.add(name)
-            }
-
-            rules.push({
-                type: 'include',
-                target: name,
-                isGroup: isGroup(name) || isMetaGroup(name),
-            })
-        } else if (isRemove) {
-            // Remove group or tool
-            if (isGroup(name)) {
-                for (const tool of TOOL_GROUPS[name]) {
-                    enabledTools.delete(tool)
-                }
-            } else {
-                enabledTools.delete(name)
-            }
-
-            rules.push({
-                type: 'exclude',
-                target: name,
-                isGroup: isGroup(name),
-            })
-        } else {
-            // Add group or tool (with or without + prefix)
-            if (isMetaGroup(name)) {
-                for (const group of META_GROUPS[name]) {
-                    enabledTools = new Set([...enabledTools, ...TOOL_GROUPS[group]])
-                }
-            } else if (isGroup(name)) {
-                enabledTools = new Set([...enabledTools, ...TOOL_GROUPS[name]])
-            } else {
-                enabledTools.add(name)
-            }
-
-            rules.push({
-                type: 'include',
-                target: name,
-                isGroup: isGroup(name) || isMetaGroup(name),
-            })
-        }
-    }
-
-    // If no filter specified or starting with removal, start with all tools
-    if (!isWhitelistMode && rules.length > 0 && rules[0]?.type === 'exclude') {
-        enabledTools = new Set(getAllToolNames())
-        // Re-apply rules
-        for (const rule of rules) {
-            if (rule.type === 'exclude') {
-                if (isGroup(rule.target)) {
-                    for (const tool of TOOL_GROUPS[rule.target]) {
-                        enabledTools.delete(tool)
-                    }
-                } else {
-                    enabledTools.delete(rule.target)
-                }
-            }
-        }
-    }
-
-    return {
-        raw: filterString,
-        rules,
-        enabledTools,
-    }
-}
-
-/**
- * Check if a tool is enabled based on filter string
- */
-export function isToolEnabled(toolName: string, filterConfig: ToolFilterConfig): boolean {
-    return filterConfig.enabledTools.has(toolName)
-}
-
-/**
- * Filter tools array based on filter configuration
- */
-export function filterTools<T extends { name: string }>(
-    tools: T[],
-    filterConfig: ToolFilterConfig
-): T[] {
-    return tools.filter((tool) => isToolEnabled(tool.name, filterConfig))
-}
-
-/**
- * Get tool filter from environment variable
- */
-export function getToolFilterFromEnv(): ToolFilterConfig | null {
-    const filterString = process.env['MEMORY_JOURNAL_MCP_TOOL_FILTER']
-    if (!filterString) return null
-    return parseToolFilter(filterString)
-}
-
-/**
- * Calculate token savings from filtering
- */
-export function calculateTokenSavings(
-    totalTools: number,
-    enabledTools: number,
-    avgTokensPerTool = 150
-): { reduction: number; savedTokens: number } {
-    const savedTokens = (totalTools - enabledTools) * avgTokensPerTool
-    const reduction = ((totalTools - enabledTools) / totalTools) * 100
-    return { reduction, savedTokens }
-}
-
-/**
- * Get human-readable filter summary
- */
-export function getFilterSummary(filterConfig: ToolFilterConfig): string {
-    const total = getAllToolNames().length
-    const enabled = filterConfig.enabledTools.size
-    const { reduction } = calculateTokenSavings(total, enabled)
-
-    return `${enabled}/${total} tools enabled (${reduction.toFixed(0)}% reduction)`
-}

package/src/github/github-integration/client.ts

@@ -1,114 +0,0 @@
-import { Octokit } from '@octokit/rest'
-import { graphql } from '@octokit/graphql'
-import * as simpleGitImport from 'simple-git'
-import { logger } from '../../utils/logger.js'
-import type { RepoInfo } from './types.js'
-
-export const CACHE_TTL_MS = 5 * 60 * 1000
-export const TRAFFIC_CACHE_TTL_MS = 10 * 60 * 1000
-
-export interface CacheEntry<T> {
-    data: T
-    timestamp: number
-}
-
-type SimpleGitType = typeof simpleGitImport.simpleGit
-const simpleGit: SimpleGitType = simpleGitImport.simpleGit
-
-export class GitHubClient {
-    public octokit: Octokit | null = null
-    public graphqlWithAuth: typeof graphql | null = null
-    public git: simpleGitImport.SimpleGit
-    public token: string | undefined
-    public cachedRepoInfo: RepoInfo | null = null
-
-    public readonly apiCache = new Map<string, CacheEntry<unknown>>()
-
-    constructor(workingDir = '.') {
-        this.token = process.env['GITHUB_TOKEN']
-
-        const envRepoPath = process.env['GITHUB_REPO_PATH']
-        const effectiveDir = envRepoPath || workingDir
-
-        const resolvedDir = effectiveDir === '.' ? process.cwd() : effectiveDir
-        logger.info('GitHub integration using directory', {
-            module: 'GitHub',
-            workingDir,
-            envRepoPath: envRepoPath ?? 'not set',
-            effectiveDir,
-            resolvedDir,
-            cwd: process.cwd(),
-        })
-
-        this.git = simpleGit(effectiveDir)
-
-        if (this.token) {
-            this.octokit = new Octokit({ auth: this.token })
-            this.graphqlWithAuth = graphql.defaults({
-                headers: { authorization: `token ${this.token}` },
-            })
-            logger.info('GitHub integration initialized with token', { module: 'GitHub' })
-        } else {
-            logger.info('GitHub integration initialized without token (limited functionality)', {
-                module: 'GitHub',
-            })
-        }
-    }
-
-    isApiAvailable(): boolean {
-        return this.octokit !== null
-    }
-
-    getCached(key: string): unknown {
-        const entry = this.apiCache.get(key)
-        if (entry && Date.now() - entry.timestamp < CACHE_TTL_MS) {
-            // Map iteration order is insertion order: delete and re-set to make it newest (LRU)
-            this.apiCache.delete(key)
-            this.apiCache.set(key, entry)
-            return entry.data
-        }
-        if (entry) {
-            this.apiCache.delete(key)
-        }
-        return undefined
-    }
-
-    getCachedWithTtl(key: string, ttlMs: number): unknown {
-        const entry = this.apiCache.get(key)
-        if (entry && Date.now() - entry.timestamp < ttlMs) {
-            // Map iteration order is insertion order: delete and re-set to make it newest (LRU)
-            this.apiCache.delete(key)
-            this.apiCache.set(key, entry)
-            return entry.data
-        }
-        if (entry) {
-            this.apiCache.delete(key)
-        }
-        return undefined
-    }
-
-    setCache(key: string, data: unknown): void {
-        this.apiCache.delete(key) // Ensure it is inserted at the end of iteration order
-        this.apiCache.set(key, { data, timestamp: Date.now() })
-
-        // Prevent unbounded memory growth (Max 100 items)
-        if (this.apiCache.size > 100) {
-            const oldestKey = this.apiCache.keys().next().value
-            if (oldestKey !== undefined) {
-                this.apiCache.delete(oldestKey)
-            }
-        }
-    }
-
-    invalidateCache(prefix: string): void {
-        for (const key of this.apiCache.keys()) {
-            if (key.startsWith(prefix)) {
-                this.apiCache.delete(key)
-            }
-        }
-    }
-
-    clearCache(): void {
-        this.apiCache.clear()
-    }
-}