memory-journal-mcp 6.1.2 → 6.2.1

package/src/handlers/resources/templates.ts

@@ -1,334 +0,0 @@
-/**
- * Memory Journal MCP Server - Template Resource Definitions
- *
- * Resources with URI templates (parameterized):
- * projects/{number}/timeline, issues/{issue_number}/entries, prs/{pr_number}/entries,
- * prs/{pr_number}/timeline, kanban/{project_number}, kanban/{project_number}/diagram
- */
-
-import { ICON_ISSUE, ICON_PR } from '../../constants/icons.js'
-import { RAW_ENTRY_COLUMNS as ENTRY_COLUMNS } from '../../database/core/entry-columns.js'
-import { ASSISTANT_FOCUSED, MEDIUM_PRIORITY } from '../../utils/resource-annotations.js'
-import type { InternalResourceDef, ResourceContext } from './shared.js'
-import { execQuery, transformEntryRow } from './shared.js'
-
-/**
- * Get template resource definitions
- */
-export function getTemplateResourceDefinitions(): InternalResourceDef[] {
-    return [
-        {
-            uri: 'memory://projects/{number}/timeline',
-            name: 'Project Timeline',
-            title: 'Project Activity Timeline',
-            description: 'Project activity timeline',
-            mimeType: 'application/json',
-            annotations: { ...MEDIUM_PRIORITY, audience: ['assistant'] },
-            handler: (uri: string, context: ResourceContext) => {
-                const match = /memory:\/\/projects\/(\d+)\/timeline/.exec(uri)
-                const projectNumber = match?.[1] ? parseInt(match[1], 10) : null
-
-                if (projectNumber === null) {
-                    return { error: 'Invalid project number' }
-                }
-
-                const rows = execQuery(
-                    context.db,
-                    `
-                    SELECT ${ENTRY_COLUMNS} FROM memory_journal
-                    WHERE project_number = ?
-                    AND deleted_at IS NULL
-                    ORDER BY timestamp DESC
-                    LIMIT 50
-                `,
-                    [projectNumber]
-                )
-                const entries = rows.map(transformEntryRow)
-                return { projectNumber, entries, count: entries.length }
-            },
-        },
-        {
-            uri: 'memory://issues/{issue_number}/entries',
-            name: 'Issue Entries',
-            title: 'Entries Linked to Issue',
-            description: 'All entries linked to a specific issue',
-            mimeType: 'application/json',
-            icons: [ICON_ISSUE],
-            annotations: { ...MEDIUM_PRIORITY, audience: ['assistant'] },
-            handler: (uri: string, context: ResourceContext) => {
-                const match = /memory:\/\/issues\/(\d+)\/entries/.exec(uri)
-                const issueNumber = match?.[1] ? parseInt(match[1], 10) : null
-
-                if (issueNumber === null) {
-                    return { error: 'Invalid issue number' }
-                }
-
-                const rows = execQuery(
-                    context.db,
-                    `
-                    SELECT ${ENTRY_COLUMNS} FROM memory_journal
-                    WHERE issue_number = ?
-                    AND deleted_at IS NULL
-                    ORDER BY timestamp DESC
-                `,
-                    [issueNumber]
-                )
-                const entries = rows.map(transformEntryRow)
-                return { issueNumber, entries, count: entries.length }
-            },
-        },
-        {
-            uri: 'memory://prs/{pr_number}/entries',
-            name: 'PR Entries',
-            title: 'Entries Linked to PR',
-            description: 'All entries linked to a specific pull request',
-            mimeType: 'application/json',
-            icons: [ICON_PR],
-            annotations: { ...MEDIUM_PRIORITY, audience: ['assistant'] },
-            handler: (uri: string, context: ResourceContext) => {
-                const match = /memory:\/\/prs\/(\d+)\/entries/.exec(uri)
-                const prNumber = match?.[1] ? parseInt(match[1], 10) : null
-
-                if (prNumber === null) {
-                    return { error: 'Invalid PR number' }
-                }
-
-                const rows = execQuery(
-                    context.db,
-                    `
-                    SELECT ${ENTRY_COLUMNS} FROM memory_journal
-                    WHERE pr_number = ?
-                    AND deleted_at IS NULL
-                    ORDER BY timestamp DESC
-                `,
-                    [prNumber]
-                )
-                const entries = rows.map(transformEntryRow)
-                return {
-                    prNumber,
-                    entries,
-                    count: entries.length,
-                    ...(entries.length === 0
-                        ? {
-                              hint: 'No journal entries linked to this PR. Use create_entry with pr_number to link entries.',
-                          }
-                        : {}),
-                }
-            },
-        },
-        {
-            uri: 'memory://prs/{pr_number}/timeline',
-            name: 'PR Timeline',
-            title: 'Combined PR and Journal Timeline',
-            description: 'Combined PR + journal timeline with live PR metadata',
-            mimeType: 'application/json',
-            icons: [ICON_PR],
-            annotations: ASSISTANT_FOCUSED,
-            handler: async (uri: string, context: ResourceContext) => {
-                const match = /memory:\/\/prs\/(\d+)\/timeline/.exec(uri)
-                const prNumber = match?.[1] ? parseInt(match[1], 10) : null
-
-                if (prNumber === null) {
-                    return { error: 'Invalid PR number' }
-                }
-
-                // Fetch live PR metadata from GitHub if available
-                let prMetadata: {
-                    title: string
-                    state: string
-                    draft: boolean
-                    mergedAt: string | null
-                    closedAt: string | null
-                    author: string
-                    headBranch: string
-                    baseBranch: string
-                } | null = null
-
-                if (context.github) {
-                    try {
-                        const repoInfo = await context.github.getRepoInfo()
-                        if (repoInfo.owner && repoInfo.repo) {
-                            const pr = await context.github.getPullRequest(
-                                repoInfo.owner,
-                                repoInfo.repo,
-                                prNumber
-                            )
-                            if (pr) {
-                                prMetadata = {
-                                    title: pr.title,
-                                    state: pr.state,
-                                    draft: pr.draft,
-                                    mergedAt: pr.mergedAt,
-                                    closedAt: pr.closedAt,
-                                    author: pr.author,
-                                    headBranch: pr.headBranch,
-                                    baseBranch: pr.baseBranch,
-                                }
-                            }
-                        }
-                    } catch {
-                        // GitHub not available, proceed without metadata
-                    }
-                }
-
-                const rows = execQuery(
-                    context.db,
-                    `
-                    SELECT ${ENTRY_COLUMNS} FROM memory_journal
-                    WHERE pr_number = ?
-                    AND deleted_at IS NULL
-                    ORDER BY timestamp DESC
-                `,
-                    [prNumber]
-                )
-                const entries = rows.map(transformEntryRow)
-
-                let timelineNote: string
-                if (prMetadata) {
-                    const stateDesc = prMetadata.state.toLowerCase()
-                    const mergedNote = prMetadata.mergedAt ? ' (merged)' : ''
-                    const draftNote = prMetadata.draft ? ' [DRAFT]' : ''
-                    timelineNote = `PR #${String(prNumber)} is ${stateDesc}${mergedNote}${draftNote}`
-                } else {
-                    timelineNote =
-                        'GitHub integration unavailable for live PR status. Entry timestamps show journal activity.'
-                }
-
-                return {
-                    prNumber,
-                    prMetadata,
-                    entries,
-                    count: entries.length,
-                    timelineNote,
-                    ...(entries.length === 0
-                        ? {
-                              hint: 'No journal entries linked to this PR. Use create_entry with pr_number to link entries.',
-                          }
-                        : {}),
-                }
-            },
-        },
-        // Kanban board resources (GitHub Projects v2)
-        {
-            uri: 'memory://kanban/{project_number}',
-            name: 'Kanban Board',
-            title: 'GitHub Project Kanban Board',
-            description: 'View a GitHub Project v2 as a Kanban board with items grouped by Status',
-            mimeType: 'application/json',
-            annotations: { ...MEDIUM_PRIORITY, audience: ['assistant'] },
-            handler: async (uri: string, context: ResourceContext) => {
-                const match = /memory:\/\/kanban\/(\d+)/.exec(uri)
-                const projectNumber = match?.[1] ? parseInt(match[1], 10) : null
-
-                if (projectNumber === null) {
-                    return { error: 'Invalid project number' }
-                }
-
-                if (!context.github) {
-                    return {
-                        error: 'GitHub integration not available',
-                        hint: 'Set GITHUB_TOKEN and GITHUB_REPO_PATH environment variables.',
-                    }
-                }
-
-                const repoInfo = await context.github.getRepoInfo()
-                const owner = repoInfo.owner
-                const repo = repoInfo.repo ?? undefined
-
-                if (!owner) {
-                    return {
-                        error: 'Could not detect repository owner',
-                        hint: 'Set GITHUB_REPO_PATH to your git repository.',
-                    }
-                }
-
-                const board = await context.github.getProjectKanban(owner, projectNumber, repo)
-                if (!board) {
-                    return {
-                        error: `Project #${String(projectNumber)} not found or Status field not configured`,
-                        projectNumber,
-                        owner,
-                        hint: 'Projects can be at user, repository, or organization level.',
-                    }
-                }
-
-                return board
-            },
-        },
-        {
-            uri: 'memory://kanban/{project_number}/diagram',
-            name: 'Kanban Diagram',
-            title: 'Kanban Board Mermaid Diagram',
-            description: 'Mermaid diagram visualization of a GitHub Project Kanban board',
-            mimeType: 'text/plain',
-            annotations: MEDIUM_PRIORITY,
-            handler: async (uri: string, context: ResourceContext) => {
-                const match = /memory:\/\/kanban\/(\d+)\/diagram/.exec(uri)
-                const projectNumber = match?.[1] ? parseInt(match[1], 10) : null
-
-                if (projectNumber === null) {
-                    return { error: 'Invalid project number' }
-                }
-
-                if (!context.github) {
-                    return 'graph LR\n  NoGitHub["GitHub integration not available \u2014 set GITHUB_TOKEN and GITHUB_REPO_PATH"]'
-                }
-
-                const repoInfo = await context.github.getRepoInfo()
-                const owner = repoInfo.owner
-                const repo = repoInfo.repo ?? undefined
-
-                if (!owner) {
-                    return 'graph LR\n  NoOwner["Repository owner not detected \u2014 set GITHUB_REPO_PATH"]'
-                }
-
-                const board = await context.github.getProjectKanban(owner, projectNumber, repo)
-                if (!board) {
-                    return `graph LR\n  NotFound["Project #${String(projectNumber)} not found \u2014 ensure project exists with a Status field"]`
-                }
-
-                // Build Mermaid diagram with subgraphs for each column
-                const lines: string[] = ['graph LR']
-
-                lines.push('  classDef issue fill:#28a745,color:#fff')
-                lines.push('  classDef pr fill:#6f42c1,color:#fff')
-                lines.push('  classDef draft fill:#6c757d,color:#fff')
-
-                for (const column of board.columns) {
-                    const safeStatus = column.status.replace(/["\s]/g, '_')
-                    lines.push(
-                        `  subgraph ${safeStatus}["${column.status} (${String(column.items.length)})"]`
-                    )
-
-                    for (const item of column.items) {
-                        const safeId = item.id.replace(/[^a-zA-Z0-9]/g, '').slice(-8)
-                        const label = item.title.slice(0, 25).replace(/["[\]]/g, "'")
-                        const typeIcon =
-                            item.type === 'ISSUE'
-                                ? '🔵'
-                                : item.type === 'PULL_REQUEST'
-                                  ? '🟣'
-                                  : '⚪'
-                        const numberStr =
-                            item.number !== undefined && item.number !== 0
-                                ? `#${String(item.number)}`
-                                : ''
-                        lines.push(`    I${safeId}["${typeIcon} ${numberStr} ${label}..."]`)
-
-                        const typeClass =
-                            item.type === 'ISSUE'
-                                ? 'issue'
-                                : item.type === 'PULL_REQUEST'
-                                  ? 'pr'
-                                  : 'draft'
-                        lines.push(`    class I${safeId} ${typeClass}`)
-                    }
-
-                    lines.push('  end')
-                }
-
-                return lines.join('\n')
-            },
-        },
-    ]
-}

package/src/handlers/tools/admin.ts

@@ -1,351 +0,0 @@
-/**
- * Admin Tool Group - 5 tools
- *
- * Tools: update_entry, delete_entry, merge_tags, rebuild_vector_index, add_to_vector_index
- */
-
-import { z } from 'zod'
-import type { ToolDefinition, ToolContext } from '../../types/index.js'
-import { formatHandlerError } from '../../utils/error-helpers.js'
-import { autoIndexEntry } from '../../utils/vector-index-helpers.js'
-import { ENTRY_TYPES, EntryOutputSchema, relaxedNumber } from './schemas.js'
-import { ErrorFieldsMixin } from './error-fields-mixin.js'
-
-// ============================================================================
-// Input Schemas
-// ============================================================================
-
-/** Strict schema — used inside handler for structured Zod errors */
-const UpdateEntrySchema = z.object({
-    entry_id: z.number(),
-    content: z.string().optional(),
-    entry_type: z.enum(ENTRY_TYPES).optional(),
-    is_personal: z.boolean().optional(),
-    tags: z.array(z.string()).optional(),
-})
-
-/** Relaxed schema — passed to SDK inputSchema so Zod enum errors reach the handler */
-const UpdateEntrySchemaMcp = z.object({
-    entry_id: relaxedNumber(),
-    content: z.string().optional(),
-    entry_type: z.string().optional(),
-    is_personal: z.boolean().optional(),
-    tags: z.array(z.string()).optional(),
-})
-
-const DeleteEntrySchema = z.object({
-    entry_id: z.number(),
-    permanent: z.boolean().optional().default(false),
-})
-
-/** Relaxed schema — passed to SDK inputSchema so type coercion errors reach the handler */
-const DeleteEntrySchemaMcp = z.object({
-    entry_id: relaxedNumber(),
-    permanent: z.boolean().optional().default(false),
-})
-
-// ============================================================================
-// Output Schemas
-// ============================================================================
-
-const UpdateEntryOutputSchema = z
-    .object({
-        success: z.boolean().optional(),
-        entry: EntryOutputSchema.optional(),
-        error: z.string().optional(),
-    })
-    .extend(ErrorFieldsMixin.shape)
-
-const DeleteEntryOutputSchema = z
-    .object({
-        success: z.boolean().optional(),
-        entryId: z.number().optional(),
-        permanent: z.boolean().optional(),
-        error: z.string().optional(),
-    })
-    .extend(ErrorFieldsMixin.shape)
-
-const MergeTagsOutputSchema = z
-    .object({
-        success: z.boolean().optional(),
-        sourceTag: z.string().optional(),
-        targetTag: z.string().optional(),
-        entriesUpdated: z.number().optional(),
-        sourceDeleted: z.boolean().optional(),
-        message: z.string().optional(),
-        error: z.string().optional(),
-    })
-    .extend(ErrorFieldsMixin.shape)
-
-const RebuildVectorIndexOutputSchema = z
-    .object({
-        success: z.boolean().optional(),
-        entriesIndexed: z.number().optional(),
-        failedEntries: z.number().optional(),
-        error: z.string().optional(),
-    })
-    .extend(ErrorFieldsMixin.shape)
-
-const AddToVectorIndexOutputSchema = z
-    .object({
-        success: z.boolean().optional(),
-        entryId: z.number().optional(),
-        error: z.string().optional(),
-    })
-    .extend(ErrorFieldsMixin.shape)
-
-// ============================================================================
-// Tool Definitions
-// ============================================================================
-
-export function getAdminTools(context: ToolContext): ToolDefinition[] {
-    const { db, vectorManager, progress } = context
-    return [
-        {
-            name: 'update_entry',
-            title: 'Update Entry',
-            description: 'Update an existing journal entry',
-            group: 'admin',
-            inputSchema: UpdateEntrySchemaMcp,
-            outputSchema: UpdateEntryOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    const input = UpdateEntrySchema.parse(params)
-                    const entry = db.updateEntry(input.entry_id, {
-                        content: input.content,
-                        entryType: input.entry_type,
-                        isPersonal: input.is_personal,
-                        tags: input.tags,
-                    })
-                    if (!entry) {
-                        return {
-                            success: false,
-                            error: `Entry ${String(input.entry_id)} not found`,
-                            code: 'RESOURCE_NOT_FOUND',
-                            category: 'resource',
-                            suggestion: 'Verify the entry ID and try again',
-                            recoverable: true,
-                        }
-                    }
-
-                    // Re-index if content changed
-                    if (input.content) {
-                        autoIndexEntry(vectorManager, entry.id, entry.content)
-                    }
-
-                    return { success: true, entry }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'delete_entry',
-            title: 'Delete Entry',
-            description: 'Delete a journal entry (soft delete with timestamp)',
-            group: 'admin',
-            inputSchema: DeleteEntrySchemaMcp,
-            outputSchema: DeleteEntryOutputSchema,
-            annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    const { entry_id, permanent } = DeleteEntrySchema.parse(params)
-                    const success = db.deleteEntry(entry_id, permanent)
-
-                    if (!success) {
-                        return {
-                            success: false,
-                            entryId: entry_id,
-                            permanent,
-                            error: `Entry ${String(entry_id)} not found`,
-                            code: 'RESOURCE_NOT_FOUND',
-                            category: 'resource',
-                            suggestion: 'Verify the entry ID and try again',
-                            recoverable: true,
-                        }
-                    }
-
-                    // Remove from vector index (non-critical if fails)
-                    if (vectorManager) {
-                        try {
-                            vectorManager.removeEntry(entry_id)
-                        } catch {
-                            // Non-critical failure, entry already deleted from DB
-                        }
-                    }
-
-                    return { success, entryId: entry_id, permanent }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'merge_tags',
-            title: 'Merge Tags',
-            description:
-                'Merge one tag into another to consolidate similar tags (e.g., merge "phase-2" into "phase2"). The source tag is deleted after merge.',
-            group: 'admin',
-            inputSchema: z.object({
-                source_tag: z.string().min(1).describe('Tag to merge from (will be deleted)'),
-                target_tag: z
-                    .string()
-                    .min(1)
-                    .describe('Tag to merge into (will be created if not exists)'),
-            }),
-            outputSchema: MergeTagsOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    const { source_tag, target_tag } = z
-                        .object({
-                            source_tag: z.string().min(1),
-                            target_tag: z.string().min(1),
-                        })
-                        .parse(params)
-
-                    if (source_tag === target_tag) {
-                        return {
-                            success: false,
-                            sourceTag: source_tag,
-                            targetTag: target_tag,
-                            entriesUpdated: 0,
-                            sourceDeleted: false,
-                            message: 'Source and target tags cannot be the same',
-                            error: 'Source and target tags must be different',
-                            code: 'VALIDATION_ERROR',
-                            category: 'validation',
-                            suggestion: 'Provide two different tag names',
-                            recoverable: true,
-                        }
-                    }
-
-                    const result = db.mergeTags(source_tag, target_tag)
-                    return {
-                        success: true,
-                        sourceTag: source_tag,
-                        targetTag: target_tag,
-                        entriesUpdated: result.entriesUpdated,
-                        sourceDeleted: result.sourceDeleted,
-                        message: `Merged "${source_tag}" into "${target_tag}". Updated ${String(result.entriesUpdated)} entries.`,
-                    }
-                } catch (error) {
-                    // Zod or domain error
-                    if (error instanceof z.ZodError) {
-                        return formatHandlerError(error)
-                    }
-                    // Domain error from db.mergeTags — try to preserve schema shape
-                    try {
-                        const parsed = z
-                            .object({ source_tag: z.string(), target_tag: z.string() })
-                            .parse(params)
-                        return {
-                            success: false,
-                            sourceTag: parsed.source_tag,
-                            targetTag: parsed.target_tag,
-                            entriesUpdated: 0,
-                            sourceDeleted: false,
-                            message: 'Tag merge failed',
-                            error: error instanceof Error ? error.message : 'Unknown error',
-                            code: 'RESOURCE_NOT_FOUND',
-                            category: 'resource',
-                            suggestion: 'Verify the source tag exists using list_tags',
-                            recoverable: true,
-                        }
-                    } catch {
-                        return formatHandlerError(error)
-                    }
-                }
-            },
-        },
-        {
-            name: 'rebuild_vector_index',
-            title: 'Rebuild Vector Index',
-            description: 'Rebuild the semantic search vector index from all existing entries',
-            group: 'admin',
-            inputSchema: z.object({}).strict(),
-            outputSchema: RebuildVectorIndexOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
-            handler: async (_params: unknown) => {
-                try {
-                    if (!vectorManager) {
-                        return {
-                            success: false,
-                            entriesIndexed: 0,
-                            error: 'Vector search not available',
-                            code: 'CONFIGURATION_ERROR',
-                            category: 'configuration',
-                            suggestion:
-                                'Enable semantic search with --auto-rebuild-index or set up the vector manager',
-                            recoverable: false,
-                        }
-                    }
-                    const { indexed, failed, firstError } = await vectorManager.rebuildIndex(
-                        db,
-                        progress
-                    )
-                    const success = indexed > 0 || failed === 0
-                    return {
-                        success,
-                        entriesIndexed: indexed,
-                        ...(failed > 0 ? { failedEntries: failed } : {}),
-                        ...(!success
-                            ? { error: firstError ?? 'All entries failed to generate embeddings' }
-                            : {}),
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'add_to_vector_index',
-            title: 'Add Entry to Vector Index',
-            description: 'Add a specific entry to the semantic search vector index',
-            group: 'admin',
-            inputSchema: z.object({ entry_id: relaxedNumber() }),
-            outputSchema: AddToVectorIndexOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: false },
-            handler: async (params: unknown) => {
-                try {
-                    const { entry_id } = z.object({ entry_id: z.number() }).parse(params)
-                    if (!vectorManager) {
-                        return {
-                            success: false,
-                            entryId: entry_id,
-                            error: 'Vector search not available',
-                            code: 'CONFIGURATION_ERROR',
-                            category: 'configuration',
-                            suggestion:
-                                'Enable semantic search with --auto-rebuild-index or set up the vector manager',
-                            recoverable: false,
-                        }
-                    }
-                    const entry = db.getEntryById(entry_id)
-                    if (!entry) {
-                        return {
-                            success: false,
-                            entryId: entry_id,
-                            error: `Entry ${String(entry_id)} not found`,
-                            code: 'RESOURCE_NOT_FOUND',
-                            category: 'resource',
-                            suggestion: 'Verify the entry ID and try again',
-                            recoverable: true,
-                        }
-                    }
-                    const result = await vectorManager.addEntry(entry_id, entry.content)
-                    return {
-                        success: result.success,
-                        entryId: entry_id,
-                        ...(result.success
-                            ? {}
-                            : { error: result.error ?? 'Failed to generate or store embedding' }),
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-    ]
-}