memory-journal-mcp 6.1.2 → 6.2.1

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

@@ -1,164 +0,0 @@
-/**
- * Team Admin Tools - 3 tools
- *
- * Tools: team_update_entry, team_delete_entry, team_merge_tags
- */
-
-import type { ToolDefinition, ToolContext } from '../../../types/index.js'
-import { formatHandlerError } from '../../../utils/error-helpers.js'
-import { TEAM_DB_ERROR_RESPONSE, fetchAuthor } from './helpers.js'
-import {
-    TeamUpdateEntrySchema,
-    TeamUpdateEntrySchemaMcp,
-    TeamDeleteEntrySchema,
-    TeamDeleteEntrySchemaMcp,
-    TeamMergeTagsSchema,
-    TeamUpdateOutputSchema,
-    TeamDeleteOutputSchema,
-    TeamMergeTagsOutputSchema,
-} from './schemas.js'
-
-// ============================================================================
-// Tool Definitions
-// ============================================================================
-
-export function getTeamAdminTools(context: ToolContext): ToolDefinition[] {
-    const { teamDb } = context
-
-    return [
-        {
-            name: 'team_update_entry',
-            title: 'Update Team Entry',
-            description: 'Update a team entry (content, type, or tags). Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: TeamUpdateEntrySchemaMcp,
-            outputSchema: TeamUpdateOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const { entry_id, content, entry_type, tags } =
-                        TeamUpdateEntrySchema.parse(params)
-
-                    // Verify entry exists
-                    const existing = teamDb.getEntryById(entry_id)
-                    if (!existing) {
-                        return {
-                            success: false,
-                            error: `Team entry ${String(entry_id)} not found`,
-                            code: 'RESOURCE_NOT_FOUND',
-                            category: 'resource',
-                            suggestion: 'Verify the team entry ID and try again',
-                            recoverable: true,
-                        }
-                    }
-
-                    const updated = teamDb.updateEntry(entry_id, {
-                        content,
-                        entryType: entry_type,
-                        tags,
-                    })
-
-                    const author = fetchAuthor(teamDb, entry_id)
-
-                    return {
-                        success: true,
-                        entry: { ...updated, author },
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'team_delete_entry',
-            title: 'Delete Team Entry',
-            description:
-                'Soft-delete a team entry (marks as deleted, preservable). Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: TeamDeleteEntrySchemaMcp,
-            outputSchema: TeamDeleteOutputSchema,
-            annotations: {
-                readOnlyHint: false,
-                destructiveHint: true,
-                idempotentHint: false,
-                openWorldHint: false,
-            },
-            handler: (params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const { entry_id } = TeamDeleteEntrySchema.parse(params)
-
-                    // Verify entry exists
-                    const existing = teamDb.getEntryById(entry_id)
-                    if (!existing) {
-                        return {
-                            success: false,
-                            error: `Team entry ${String(entry_id)} not found`,
-                            code: 'RESOURCE_NOT_FOUND',
-                            category: 'resource',
-                            suggestion: 'Verify the team entry ID and try again',
-                            recoverable: true,
-                        }
-                    }
-
-                    teamDb.deleteEntry(entry_id)
-
-                    return {
-                        success: true,
-                        message: `Team entry ${String(entry_id)} soft-deleted`,
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'team_merge_tags',
-            title: 'Merge Team Tags',
-            description:
-                'Merge a source tag into a target tag in the team database. All entries with the source tag will be re-tagged with the target tag. Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: TeamMergeTagsSchema,
-            outputSchema: TeamMergeTagsOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const { source_tag, target_tag } = TeamMergeTagsSchema.parse(params)
-
-                    if (source_tag === target_tag) {
-                        return {
-                            success: false,
-                            error: 'Source and target tags must be different',
-                            code: 'VALIDATION_ERROR',
-                            category: 'validation',
-                            suggestion: 'Provide two different tag names',
-                            recoverable: true,
-                        }
-                    }
-
-                    const result = teamDb.mergeTags(source_tag, target_tag)
-
-                    return {
-                        success: true,
-                        message: `Merged tag "${source_tag}" into "${target_tag}". Updated ${String(result.entriesUpdated)} entries.`,
-                        entriesUpdated: result.entriesUpdated,
-                        sourceDeleted: result.sourceDeleted,
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-    ]
-}

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

@@ -1,233 +0,0 @@
-/**
- * Team Analytics Tools - 2 tools
- *
- * Tools: team_get_statistics, team_get_cross_project_insights
- */
-
-import type { ToolDefinition, ToolContext } from '../../../types/index.js'
-import { formatHandlerError } from '../../../utils/error-helpers.js'
-import { TEAM_DB_ERROR_RESPONSE } from './helpers.js'
-import {
-    TeamGetStatisticsSchema,
-    TeamGetStatisticsSchemaMcp,
-    TeamStatisticsOutputSchema,
-    TeamCrossProjectInsightsSchema,
-    TeamCrossProjectInsightsSchemaMcp,
-    TeamCrossProjectInsightsOutputSchema,
-} from './schemas.js'
-
-// Named constants (magic value extraction)
-const INACTIVE_THRESHOLD_DAYS = 7
-const MS_PER_DAY = 86_400_000
-const MAX_TAGS_PER_PROJECT = 5
-
-// ============================================================================
-// Tool Definitions
-// ============================================================================
-
-export function getTeamAnalyticsTools(context: ToolContext): ToolDefinition[] {
-    const { teamDb } = context
-
-    return [
-        {
-            name: 'team_get_statistics',
-            title: 'Get Team Statistics',
-            description:
-                'Get statistics for the team database including entry counts, types, top tags, and contributor breakdown. Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: TeamGetStatisticsSchemaMcp,
-            outputSchema: TeamStatisticsOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const { group_by } = TeamGetStatisticsSchema.parse(params)
-                    const stats = teamDb.getStatistics(group_by)
-
-                    // Author breakdown
-                    let authors: { author: string; count: number }[] = []
-                    try {
-                        const authorResult = teamDb.executeRawQuery(
-                            `SELECT COALESCE(author, 'unknown') as author, COUNT(*) as count
-                             FROM memory_journal
-                             WHERE deleted_at IS NULL
-                             GROUP BY COALESCE(author, 'unknown')
-                             ORDER BY count DESC`
-                        )
-                        if (authorResult[0]) {
-                            authors = authorResult[0].values.map((row: unknown[]) => ({
-                                author: row[0] as string,
-                                count: row[1] as number,
-                            }))
-                        }
-                    } catch {
-                        // Author column may not exist yet
-                    }
-
-                    return {
-                        success: true,
-                        ...(stats as object),
-                        authors,
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'team_get_cross_project_insights',
-            title: 'Team Cross-Project Insights',
-            description:
-                'Analyze patterns across all GitHub Projects tracked in team entries. Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: TeamCrossProjectInsightsSchemaMcp,
-            outputSchema: TeamCrossProjectInsightsOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const input = TeamCrossProjectInsightsSchema.parse(params)
-
-                    // Build WHERE clause
-                    let where = 'WHERE deleted_at IS NULL AND project_number IS NOT NULL'
-                    const sqlParams: unknown[] = []
-
-                    if (input.start_date) {
-                        where += ' AND DATE(timestamp) >= DATE(?)'
-                        sqlParams.push(input.start_date)
-                    }
-                    if (input.end_date) {
-                        where += ' AND DATE(timestamp) <= DATE(?)'
-                        sqlParams.push(input.end_date)
-                    }
-
-                    // Get active projects with stats
-                    const projectsResult = teamDb.executeRawQuery(
-                        `
-                        SELECT project_number, COUNT(*) as entry_count,
-                               MIN(DATE(timestamp)) as first_entry,
-                               MAX(DATE(timestamp)) as last_entry,
-                               COUNT(DISTINCT DATE(timestamp)) as active_days
-                        FROM memory_journal ${where}
-                        GROUP BY project_number
-                        HAVING entry_count >= ?
-                        ORDER BY entry_count DESC
-                        LIMIT ?
-                    `,
-                        [...sqlParams, input.min_entries, input.limit]
-                    )
-
-                    if (!projectsResult[0] || projectsResult[0].values.length === 0) {
-                        return {
-                            project_count: 0,
-                            total_entries: 0,
-                            projects: [],
-                            inactive_projects: [],
-                            inactiveThresholdDays: INACTIVE_THRESHOLD_DAYS,
-                            time_distribution: [],
-                            message: `No projects found with at least ${String(input.min_entries)} entries`,
-                        }
-                    }
-
-                    const columns = projectsResult[0].columns
-                    const projects = projectsResult[0].values.map((row: unknown[]) => {
-                        const obj: Record<string, unknown> = {}
-                        columns.forEach((col: string, i: number) => {
-                            obj[col] = row[i]
-                        })
-                        return obj
-                    })
-
-                    // Get top tags per project (batch query instead of N+1)
-                    const projectTags: Record<number, { name: string; count: number }[]> = {}
-                    const projectNumbers = projects.map((p) => p['project_number'] as number)
-                    if (projectNumbers.length > 0) {
-                        const tagPlaceholders = projectNumbers.map(() => '?').join(',')
-                        const allTagsResult = teamDb.executeRawQuery(
-                            `
-                            SELECT m.project_number, t.name, COUNT(*) as count
-                            FROM tags t
-                            JOIN entry_tags et ON t.id = et.tag_id
-                            JOIN memory_journal m ON et.entry_id = m.id
-                            WHERE m.project_number IN (${tagPlaceholders}) AND m.deleted_at IS NULL
-                            GROUP BY m.project_number, t.name
-                            ORDER BY m.project_number, count DESC
-                            `,
-                            projectNumbers
-                        )
-                        if (allTagsResult[0]) {
-                            for (const row of allTagsResult[0].values) {
-                                const projNum = row[0] as number
-                                const tagEntry = {
-                                    name: row[1] as string,
-                                    count: row[2] as number,
-                                }
-                                const existing = projectTags[projNum] ?? []
-                                if (existing.length < MAX_TAGS_PER_PROJECT) {
-                                    existing.push(tagEntry)
-                                    projectTags[projNum] = existing
-                                }
-                            }
-                        }
-                    }
-
-                    // Find inactive projects (last entry > threshold days ago)
-                    const cutoffDate = new Date(Date.now() - INACTIVE_THRESHOLD_DAYS * MS_PER_DAY)
-                        .toISOString()
-                        .split('T')[0]
-                    const inactiveResult = teamDb.executeRawQuery(
-                        `
-                        SELECT project_number, MAX(DATE(timestamp)) as last_entry_date
-                        FROM memory_journal
-                        WHERE deleted_at IS NULL AND project_number IS NOT NULL
-                        GROUP BY project_number
-                        HAVING last_entry_date < ?
-                        ORDER BY last_entry_date DESC
-                        LIMIT ?
-                    `,
-                        [cutoffDate, input.limit]
-                    )
-
-                    const inactiveProjects =
-                        inactiveResult[0]?.values.map((row: unknown[]) => ({
-                            project_number: row[0] as number,
-                            last_entry_date: row[1] as string,
-                        })) ?? []
-
-                    // Calculate time distribution
-                    const totalEntries = projects.reduce(
-                        (sum: number, p: Record<string, unknown>) =>
-                            sum + (p['entry_count'] as number),
-                        0
-                    )
-                    const distribution = projects.slice(0, 5).map((p: Record<string, unknown>) => ({
-                        project_number: p['project_number'] as number,
-                        percentage: (((p['entry_count'] as number) / totalEntries) * 100).toFixed(
-                            1
-                        ),
-                    }))
-
-                    return {
-                        project_count: projects.length,
-                        total_entries: totalEntries,
-                        projects: projects.map((p) => ({
-                            ...p,
-                            top_tags: projectTags[p['project_number'] as number] ?? [],
-                        })),
-                        inactive_projects: inactiveProjects,
-                        inactiveThresholdDays: INACTIVE_THRESHOLD_DAYS,
-                        time_distribution: distribution,
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-    ]
-}

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

@@ -1,83 +0,0 @@
-/**
- * Team Backup Tools - 2 tools
- *
- * Tools: team_backup, team_list_backups
- */
-
-import { z } from 'zod'
-import type { ToolDefinition, ToolContext } from '../../../types/index.js'
-import { formatHandlerError } from '../../../utils/error-helpers.js'
-import { TEAM_DB_ERROR_RESPONSE } from './helpers.js'
-import { TeamBackupSchema, TeamBackupOutputSchema, TeamBackupsListOutputSchema } from './schemas.js'
-
-// ============================================================================
-// Tool Definitions
-// ============================================================================
-
-export function getTeamBackupTools(context: ToolContext): ToolDefinition[] {
-    const { teamDb } = context
-
-    return [
-        {
-            name: 'team_backup',
-            title: 'Backup Team Database',
-            description: 'Create a timestamped backup of the team database. Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: TeamBackupSchema,
-            outputSchema: TeamBackupOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
-            handler: async (params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const input = TeamBackupSchema.parse(params)
-                    const result = await teamDb.exportToFile(input.name)
-
-                    return {
-                        success: true,
-                        message: 'Team database backup created successfully',
-                        filename: result.filename,
-                        path: result.path,
-                        sizeBytes: result.sizeBytes,
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'team_list_backups',
-            title: 'List Team Backups',
-            description:
-                'List all available backup files for the team database. Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: z.object({}).strict(),
-            outputSchema: TeamBackupsListOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-            handler: (_params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const backups = teamDb.listBackups()
-
-                    return {
-                        success: true,
-                        backups,
-                        total: backups.length,
-                        backupsDirectory: teamDb.getBackupsDir(),
-                        hint:
-                            backups.length === 0
-                                ? 'No team backups found. Use team_backup to create one.'
-                                : undefined,
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-    ]
-}

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

@@ -1,197 +0,0 @@
-/**
- * Team Core Tools - 4 tools
- *
- * Tools: team_create_entry, team_get_entry_by_id, team_get_recent, team_list_tags
- */
-
-import { z } from 'zod'
-import type { ToolDefinition, ToolContext } from '../../../types/index.js'
-import { formatHandlerError } from '../../../utils/error-helpers.js'
-import { resolveAuthor } from '../../../utils/security-utils.js'
-import { resolveIssueUrl } from '../../../utils/github-helpers.js'
-import { TEAM_DB_ERROR_RESPONSE, batchFetchAuthors, fetchAuthor } from './helpers.js'
-import {
-    TeamCreateEntrySchema,
-    TeamCreateEntrySchemaMcp,
-    TeamGetRecentSchema,
-    TeamGetRecentSchemaMcp,
-    TeamGetEntryByIdSchema,
-    TeamGetEntryByIdSchemaMcp,
-    TeamCreateOutputSchema,
-    TeamEntriesListOutputSchema,
-    TeamEntryDetailOutputSchema,
-    TeamTagsListOutputSchema,
-} from './schemas.js'
-
-// ============================================================================
-// Tool Definitions
-// ============================================================================
-
-export function getTeamCoreTools(context: ToolContext): ToolDefinition[] {
-    const { teamDb, github } = context
-
-    return [
-        {
-            name: 'team_create_entry',
-            title: 'Create Team Entry',
-            description:
-                'Create an entry in the team database for sharing with collaborators. Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: TeamCreateEntrySchemaMcp,
-            outputSchema: TeamCreateOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const input = TeamCreateEntrySchema.parse(params)
-                    const author = input.author ?? resolveAuthor()
-
-                    const resolvedIssueUrl = resolveIssueUrl(
-                        github,
-                        input.issue_number,
-                        input.issue_url
-                    )
-
-                    const entry = teamDb.createEntry({
-                        content: input.content,
-                        entryType: input.entry_type,
-                        tags: input.tags,
-                        isPersonal: false,
-                        significanceType: input.significance_type ?? null,
-                        autoContext: JSON.stringify({ author }),
-                        projectNumber: input.project_number,
-                        projectOwner: input.project_owner,
-                        issueNumber: input.issue_number,
-                        issueUrl: resolvedIssueUrl,
-                        prNumber: input.pr_number,
-                        prUrl: input.pr_url,
-                        prStatus: input.pr_status,
-                    })
-
-                    teamDb.executeRawQuery('UPDATE memory_journal SET author = ? WHERE id = ?', [
-                        author,
-                        entry.id,
-                    ])
-                    teamDb.flushSave()
-
-                    return {
-                        success: true,
-                        entry: { ...entry, author },
-                        author,
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'team_get_entry_by_id',
-            title: 'Get Team Entry by ID',
-            description:
-                'Get a specific team entry by ID with full details including relationships and importance score. Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: TeamGetEntryByIdSchemaMcp,
-            outputSchema: TeamEntryDetailOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const { entry_id, include_relationships } = TeamGetEntryByIdSchema.parse(params)
-                    const entry = teamDb.getEntryById(entry_id)
-
-                    if (!entry) {
-                        return {
-                            success: false,
-                            error: `Team entry ${String(entry_id)} not found`,
-                            code: 'RESOURCE_NOT_FOUND',
-                            category: 'resource',
-                            suggestion: 'Verify the team entry ID and try again',
-                            recoverable: true,
-                        }
-                    }
-
-                    const author = fetchAuthor(teamDb, entry_id)
-                    const enrichedEntry = { ...entry, author }
-
-                    const result: Record<string, unknown> = {
-                        success: true,
-                        entry: enrichedEntry,
-                    }
-
-                    if (include_relationships) {
-                        const relationships = teamDb.getRelationships(entry_id)
-                        result['relationships'] = relationships
-                    }
-
-                    const importance = teamDb.calculateImportance(entry_id)
-                    result['importance'] = importance
-
-                    return result
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'team_get_recent',
-            title: 'Get Recent Team Entries',
-            description: 'Get recent entries from the team database. Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: TeamGetRecentSchemaMcp,
-            outputSchema: TeamEntriesListOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const { limit } = TeamGetRecentSchema.parse(params)
-                    const entries = teamDb.getRecentEntries(limit)
-
-                    const authorMap = batchFetchAuthors(
-                        teamDb,
-                        entries.map((e) => e.id)
-                    )
-                    const enriched = entries.map((e) => ({
-                        ...e,
-                        author: authorMap.get(e.id) ?? null,
-                    }))
-
-                    return { entries: enriched, count: enriched.length }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'team_list_tags',
-            title: 'List Team Tags',
-            description:
-                'List all tags used in the team database with usage counts. Requires TEAM_DB_PATH.',
-            group: 'team',
-            inputSchema: z.object({}).strict(),
-            outputSchema: TeamTagsListOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-            handler: (_params: unknown) => {
-                try {
-                    if (!teamDb) {
-                        return { ...TEAM_DB_ERROR_RESPONSE }
-                    }
-
-                    const rawTags = teamDb.listTags()
-                    const tags = rawTags.map((t) => ({ name: t.name, count: t.usageCount }))
-                    return { success: true, tags, count: tags.length }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-    ]
-}