memory-journal-mcp 6.1.2 → 6.2.1

package/src/handlers/tools/team/export-tools.ts

@@ -1,130 +0,0 @@
-/**
- * Team Export Tools - 1 tool
- *
- * Tools: team_export_entries
- */
-
-import type { ToolDefinition, ToolContext } from '../../../types/index.js'
-import { formatHandlerError } from '../../../utils/error-helpers.js'
-import { sendProgress } from '../../../utils/progress-utils.js'
-import { DATE_MIN_SENTINEL, DATE_MAX_SENTINEL } from '../schemas.js'
-import { TEAM_DB_ERROR_RESPONSE, batchFetchAuthors } from './helpers.js'
-import {
-    TeamExportEntriesSchema,
-    TeamExportEntriesSchemaMcp,
-    TeamExportOutputSchema,
-} from './schemas.js'
-
-// ============================================================================
-// Tool Definitions
-// ============================================================================
-
-export function getTeamExportTools(context: ToolContext): ToolDefinition[] {
-    const { teamDb, progress } = context
-
-    return [
-        {
-            name: 'team_export_entries',
-            title: 'Export Team Entries',
-            description:
-                'Export team entries in JSON or Markdown format with optional date range, type, and tag filters. Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: TeamExportEntriesSchemaMcp,
-            outputSchema: TeamExportOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-            handler: async (params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const { format, start_date, end_date, entry_type, tags, limit } =
-                        TeamExportEntriesSchema.parse(params)
-
-                    await sendProgress(progress, 1, 3, 'Fetching team entries...')
-
-                    // When entry_type or tags filters are active, fetch a larger
-                    // batch so post-filtering doesn't silently return too few results.
-                    const hasTypeFilter = !!entry_type
-                    const hasTagFilter = tags && tags.length > 0
-                    const fetchLimit = hasTypeFilter || hasTagFilter ? 500 : limit
-
-                    // Fetch entries with optional filters
-                    let entries
-                    if (start_date && end_date) {
-                        entries = teamDb.searchByDateRange(start_date, end_date, {
-                            entryType: entry_type,
-                            tags,
-                            limit: fetchLimit,
-                        })
-                    } else if (hasTypeFilter || hasTagFilter) {
-                        // Use wide date range to scan the full database
-                        entries = teamDb.searchByDateRange(DATE_MIN_SENTINEL, DATE_MAX_SENTINEL, {
-                            entryType: entry_type,
-                            tags,
-                            limit: fetchLimit,
-                        })
-                    } else {
-                        entries = teamDb.getRecentEntries(fetchLimit)
-                    }
-
-                    // Post-filter by entry_type if searchByDateRange
-                    // doesn't natively support it, then cap to requested limit
-                    if (hasTypeFilter && entries.length > limit) {
-                        entries = entries.slice(0, limit)
-                    }
-                    if (hasTagFilter && entries.length > limit) {
-                        entries = entries.slice(0, limit)
-                    }
-
-                    await sendProgress(progress, 2, 3, 'Formatting export data...')
-
-                    // Enrich with authors
-                    const authorMap = batchFetchAuthors(
-                        teamDb,
-                        entries.map((e) => e.id)
-                    )
-                    const enriched = entries.map((e) => ({
-                        ...e,
-                        author: authorMap.get(e.id) ?? null,
-                    }))
-
-                    let data: string
-                    if (format === 'markdown') {
-                        const lines: string[] = ['# Team Journal Export', '']
-                        for (const entry of enriched) {
-                            lines.push(`## Entry #${String(entry.id)}`)
-                            lines.push(`**Date:** ${entry.timestamp}`)
-                            lines.push(`**Type:** ${entry.entryType}`)
-                            if (entry.author) {
-                                lines.push(`**Author:** ${entry.author}`)
-                            }
-                            if (entry.tags !== undefined && entry.tags.length > 0) {
-                                lines.push(`**Tags:** ${entry.tags.join(', ')}`)
-                            }
-                            lines.push('')
-                            lines.push(entry.content)
-                            lines.push('')
-                            lines.push('---')
-                            lines.push('')
-                        }
-                        data = lines.join('\n')
-                    } else {
-                        data = JSON.stringify(enriched)
-                    }
-
-                    await sendProgress(progress, 3, 3, 'Export complete')
-
-                    return {
-                        success: true,
-                        format,
-                        data,
-                        count: enriched.length,
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-    ]
-}

package/src/handlers/tools/team/helpers.ts

@@ -1,66 +0,0 @@
-/**
- * Team Tool Helpers
- *
- * Shared constants and utilities used across all team tool sub-modules.
- */
-
-import type { ToolContext } from '../../../types/index.js'
-
-// ============================================================================
-// Constants
-// ============================================================================
-
-export const TEAM_DB_NOT_CONFIGURED =
-    'Team database not configured. Set TEAM_DB_PATH environment variable to enable team collaboration.'
-
-/** Structured error response for unconfigured team DB — reused by all 20 team tools. */
-export const TEAM_DB_ERROR_RESPONSE = {
-    success: false as const,
-    error: TEAM_DB_NOT_CONFIGURED,
-    code: 'CONFIGURATION_ERROR',
-    category: 'configuration',
-    suggestion:
-        'Set TEAM_DB_PATH environment variable or --team-db CLI flag to enable team collaboration.',
-    recoverable: true,
-}
-
-// ============================================================================
-// Author Helpers
-// ============================================================================
-
-/**
- * Batch-fetch author names for a list of entry IDs.
- * Returns a Map<entryId, author> for O(1) lookups.
- */
-export function batchFetchAuthors(
-    teamDb: NonNullable<ToolContext['teamDb']>,
-    entryIds: number[]
-): Map<number, string | null> {
-    const authorMap = new Map<number, string | null>()
-    if (entryIds.length === 0) return authorMap
-
-    const placeholders = entryIds.map(() => '?').join(',')
-    const result = teamDb.executeRawQuery(
-        `SELECT id, author FROM memory_journal WHERE id IN (${placeholders})`,
-        entryIds
-    )
-    if (result[0]) {
-        for (const row of result[0].values) {
-            authorMap.set(row[0] as number, (row[1] as string) ?? null)
-        }
-    }
-    return authorMap
-}
-
-/**
- * Fetch a single author for an entry ID.
- */
-export function fetchAuthor(
-    teamDb: NonNullable<ToolContext['teamDb']>,
-    entryId: number
-): string | null {
-    const result = teamDb.executeRawQuery('SELECT author FROM memory_journal WHERE id = ?', [
-        entryId,
-    ])
-    return (result[0]?.values[0]?.[0] as string) ?? null
-}

package/src/handlers/tools/team/index.ts

@@ -1,45 +0,0 @@
-/**
- * Team Tool Group - 20 tools
- *
- * Barrel re-export composing all team tool sub-modules.
- *
- * Tools:
- *   Core:          team_create_entry, team_get_entry_by_id, team_get_recent, team_list_tags
- *   Search:        team_search, team_search_by_date_range
- *   Admin:         team_update_entry, team_delete_entry, team_merge_tags
- *   Analytics:     team_get_statistics, team_get_cross_project_insights
- *   Relationships: team_link_entries, team_visualize_relationships
- *   Export:        team_export_entries
- *   Backup:        team_backup, team_list_backups
- *   Vector:        team_semantic_search, team_get_vector_index_stats,
- *                  team_rebuild_vector_index, team_add_to_vector_index
- *
- * Requires TEAM_DB_PATH to be configured. All tools return structured
- * errors when the team database is not available.
- */
-
-import type { ToolDefinition, ToolContext } from '../../../types/index.js'
-import { getTeamCoreTools } from './core-tools.js'
-import { getTeamSearchTools } from './search-tools.js'
-import { getTeamAdminTools } from './admin-tools.js'
-import { getTeamAnalyticsTools } from './analytics-tools.js'
-import { getTeamRelationshipTools } from './relationship-tools.js'
-import { getTeamExportTools } from './export-tools.js'
-import { getTeamBackupTools } from './backup-tools.js'
-import { getTeamVectorTools } from './vector-tools.js'
-
-/**
- * Get all team tool definitions (20 tools).
- */
-export function getTeamTools(context: ToolContext): ToolDefinition[] {
-    return [
-        ...getTeamCoreTools(context),
-        ...getTeamSearchTools(context),
-        ...getTeamAdminTools(context),
-        ...getTeamAnalyticsTools(context),
-        ...getTeamRelationshipTools(context),
-        ...getTeamExportTools(context),
-        ...getTeamBackupTools(context),
-        ...getTeamVectorTools(context),
-    ]
-}

package/src/handlers/tools/team/relationship-tools.ts

@@ -1,219 +0,0 @@
-/**
- * Team Relationship Tools - 2 tools
- *
- * Tools: team_link_entries, team_visualize_relationships
- */
-
-import type { ToolDefinition, ToolContext } from '../../../types/index.js'
-import { formatHandlerError } from '../../../utils/error-helpers.js'
-import { TEAM_DB_ERROR_RESPONSE } from './helpers.js'
-import {
-    TeamLinkEntriesSchema,
-    TeamLinkEntriesSchemaMcp,
-    TeamVisualizeRelationshipsSchema,
-    TeamVisualizeRelationshipsSchemaMcp,
-    TeamLinkEntriesOutputSchema,
-    TeamVisualizeOutputSchema,
-} from './schemas.js'
-
-// ============================================================================
-// Tool Definitions
-// ============================================================================
-
-export function getTeamRelationshipTools(context: ToolContext): ToolDefinition[] {
-    const { teamDb } = context
-
-    return [
-        {
-            name: 'team_link_entries',
-            title: 'Link Team Entries',
-            description: 'Create a relationship between two team entries. Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: TeamLinkEntriesSchemaMcp,
-            outputSchema: TeamLinkEntriesOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const { from_entry_id, to_entry_id, relationship_type, description } =
-                        TeamLinkEntriesSchema.parse(params)
-
-                    // Verify both entries exist
-                    const fromEntry = teamDb.getEntryById(from_entry_id)
-                    if (!fromEntry) {
-                        return {
-                            success: false,
-                            error: `Team entry ${String(from_entry_id)} not found`,
-                            code: 'RESOURCE_NOT_FOUND',
-                            category: 'resource',
-                            suggestion: 'Verify the team entry ID and try again',
-                            recoverable: true,
-                        }
-                    }
-                    const toEntry = teamDb.getEntryById(to_entry_id)
-                    if (!toEntry) {
-                        return {
-                            success: false,
-                            error: `Team entry ${String(to_entry_id)} not found`,
-                            code: 'RESOURCE_NOT_FOUND',
-                            category: 'resource',
-                            suggestion: 'Verify the team entry ID and try again',
-                            recoverable: true,
-                        }
-                    }
-
-                    // Check for existing relationship (exact direction only).
-                    // Reverse direction is allowed to model bidirectional relationships.
-                    const existing = teamDb.getRelationships(from_entry_id)
-                    const duplicate = existing.find(
-                        (r) =>
-                            r.fromEntryId === from_entry_id &&
-                            r.toEntryId === to_entry_id &&
-                            r.relationshipType === relationship_type
-                    )
-
-                    if (duplicate) {
-                        return {
-                            success: true,
-                            duplicate: true,
-                            relationship: duplicate,
-                            message: 'Relationship already exists',
-                        }
-                    }
-
-                    const relationship = teamDb.linkEntries(
-                        from_entry_id,
-                        to_entry_id,
-                        relationship_type,
-                        description
-                    )
-
-                    return {
-                        success: true,
-                        relationship,
-                        message: `Linked entries ${String(from_entry_id)} → ${String(to_entry_id)} (${relationship_type})`,
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'team_visualize_relationships',
-            title: 'Visualize Team Relationships',
-            description:
-                'Generate a Mermaid diagram showing relationships between team entries. Filter by entry ID, tag, or traverse to a specified depth. Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: TeamVisualizeRelationshipsSchemaMcp,
-            outputSchema: TeamVisualizeOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const { entry_id, tag, depth } = TeamVisualizeRelationshipsSchema.parse(params)
-
-                    // Collect entry IDs to visualize
-                    let entryIds: number[] = []
-
-                    if (entry_id !== undefined) {
-                        // Start from a specific entry and traverse
-                        entryIds = [entry_id]
-                        const visited = new Set<number>(entryIds)
-                        let frontier = [...entryIds]
-
-                        for (let d = 0; d < depth; d++) {
-                            const nextFrontier: number[] = []
-                            for (const fid of frontier) {
-                                const rels = teamDb.getRelationships(fid)
-                                for (const r of rels) {
-                                    const otherId =
-                                        r.fromEntryId === fid ? r.toEntryId : r.fromEntryId
-                                    if (!visited.has(otherId)) {
-                                        visited.add(otherId)
-                                        nextFrontier.push(otherId)
-                                    }
-                                }
-                            }
-                            frontier = nextFrontier
-                            entryIds.push(...nextFrontier)
-                        }
-                    } else if (tag) {
-                        // Get entries by tag using an all-time date range to bypass date filtering
-                        const tagEntries = teamDb.searchByDateRange('1970-01-01', '2999-12-31', {
-                            tags: [tag],
-                            limit: 50,
-                        })
-                        entryIds = tagEntries.map((e) => e.id)
-                    } else {
-                        // Default: recent entries
-                        const recent = teamDb.getRecentEntries(20)
-                        entryIds = recent.map((e) => e.id)
-                    }
-
-                    if (entryIds.length === 0) {
-                        return {
-                            success: true,
-                            mermaid: 'graph LR\n  empty["No entries found"]',
-                            nodeCount: 0,
-                            edgeCount: 0,
-                        }
-                    }
-
-                    // Build graph
-                    const nodes = new Map<number, string>()
-                    const edges: { from: number; to: number; type: string }[] = []
-                    const seenEdges = new Set<string>()
-
-                    for (const eid of entryIds) {
-                        const entry = teamDb.getEntryById(eid)
-                        if (entry) {
-                            const label = entry.content.substring(0, 40).replace(/"/g, "'")
-                            nodes.set(eid, label)
-                        }
-
-                        const rels = teamDb.getRelationships(eid)
-                        for (const r of rels) {
-                            const edgeKey = `${String(r.fromEntryId)}-${String(r.toEntryId)}`
-                            if (
-                                !seenEdges.has(edgeKey) &&
-                                entryIds.includes(r.fromEntryId) &&
-                                entryIds.includes(r.toEntryId)
-                            ) {
-                                seenEdges.add(edgeKey)
-                                edges.push({
-                                    from: r.fromEntryId,
-                                    to: r.toEntryId,
-                                    type: r.relationshipType,
-                                })
-                            }
-                        }
-                    }
-
-                    // Generate Mermaid
-                    let mermaid = 'graph LR\n'
-                    for (const [id, label] of nodes) {
-                        mermaid += `  e${String(id)}["#${String(id)}: ${label}"]\n`
-                    }
-                    for (const edge of edges) {
-                        mermaid += `  e${String(edge.from)} -->|${edge.type}| e${String(edge.to)}\n`
-                    }
-
-                    return {
-                        success: true,
-                        mermaid,
-                        nodeCount: nodes.size,
-                        edgeCount: edges.length,
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-    ]
-}