memory-journal-mcp 6.1.2 → 6.2.1

package/src/handlers/tools/codemode.ts

@@ -1,188 +0,0 @@
-/**
- * Code Mode Tool Group - 1 tool
- *
- * Tools: mj_execute_code
- *
- * Sandboxed JavaScript execution enabling multi-step journal operations
- * in a single tool call. Exposes all tool groups as `mj.*` API.
- */
-
-import { z } from 'zod'
-import type { ToolDefinition, ToolContext } from '../../types/index.js'
-import { formatHandlerError } from '../../utils/error-helpers.js'
-import { relaxedNumber } from './schemas.js'
-import { createJournalApi } from '../../codemode/api.js'
-import { CodeModeSecurityManager } from '../../codemode/security.js'
-import { createSandboxPool, type ISandboxPool } from '../../codemode/sandbox-factory.js'
-import { getCoreTools } from './core.js'
-import { getSearchTools } from './search.js'
-import { getAnalyticsTools } from './analytics.js'
-import { getRelationshipTools } from './relationships.js'
-import { getExportTools } from './export.js'
-import { getAdminTools } from './admin.js'
-import { getGitHubTools } from './github.js'
-import { getBackupTools } from './backup.js'
-import { getTeamTools } from './team/index.js'
-
-// =============================================================================
-// Input / Output Schemas
-// =============================================================================
-
-const ExecuteCodeSchema = z.object({
-    code: z.string().min(1),
-    timeout: z.number().max(30000).optional().default(30000),
-    readonly: z.boolean().optional().default(false),
-})
-
-/** Relaxed schema for MCP registration */
-const ExecuteCodeSchemaMcp = z.object({
-    code: z.string().describe('JavaScript code to execute in the sandbox'),
-    timeout: relaxedNumber()
-        .optional()
-        .default(30000)
-        .describe('Execution timeout in ms (max 30000)'),
-    readonly: z.boolean().optional().default(false).describe('Restrict to read-only operations'),
-})
-
-// No outputSchema — Code Mode returns dynamic result types (z.unknown()) which
-// produces a bare {} JSON Schema. Clients that process structuredContent crash
-// when iterating properties of {}. Using the plain text JSON response path instead.
-
-// =============================================================================
-// Singleton State
-// =============================================================================
-
-let securityManager: CodeModeSecurityManager | null = null
-let sandboxPool: ISandboxPool | null = null
-
-function getSecurityManager(): CodeModeSecurityManager {
-    securityManager ??= new CodeModeSecurityManager()
-    return securityManager
-}
-
-function getSandboxPool(): ISandboxPool {
-    sandboxPool ??= createSandboxPool()
-    return sandboxPool
-}
-
-// =============================================================================
-// Helper: Collect Non-CodeMode Tools (cached)
-// =============================================================================
-
-/**
- * Cached non-codemode tool list. Invalidates when context identity changes
- * (same approach as toolMapCache in handlers/tools/index.ts).
- */
-let cachedNonCodeModeTools: ToolDefinition[] | null = null
-let cachedCodeModeContext: ToolContext | null = null
-
-/**
- * Collect all tool definitions except codemode (prevents recursion).
- * Results are cached by referential identity of the ToolContext.
- */
-function collectNonCodeModeTools(context: ToolContext): ToolDefinition[] {
-    if (cachedNonCodeModeTools && cachedCodeModeContext === context) {
-        return cachedNonCodeModeTools
-    }
-
-    cachedNonCodeModeTools = [
-        ...getCoreTools(context),
-        ...getSearchTools(context),
-        ...getAnalyticsTools(context),
-        ...getRelationshipTools(context),
-        ...getExportTools(context),
-        ...getAdminTools(context),
-        ...getGitHubTools(context),
-        ...getBackupTools(context),
-        ...getTeamTools(context),
-    ]
-    cachedCodeModeContext = context
-    return cachedNonCodeModeTools
-}
-
-// =============================================================================
-// Tool Definitions
-// =============================================================================
-
-export function getCodeModeTools(context: ToolContext): ToolDefinition[] {
-    return [
-        {
-            name: 'mj_execute_code',
-            title: 'Execute Code (Code Mode)',
-            description:
-                'Execute JavaScript in a sandboxed environment with access to all journal tools via the `mj.*` API. ' +
-                'Enables multi-step workflows in a single call, reducing token usage by 70-90%. ' +
-                'API groups: mj.core.*, mj.search.*, mj.analytics.*, mj.relationships.*, ' +
-                'mj.export.*, mj.admin.*, mj.github.*, mj.backup.*, mj.team.*. ' +
-                'Use mj.help() for method listing. Returns the last expression value.',
-            group: 'codemode',
-            inputSchema: ExecuteCodeSchemaMcp,
-            annotations: {
-                readOnlyHint: false,
-                idempotentHint: false,
-                openWorldHint: false,
-            },
-            handler: (params: unknown) => {
-                try {
-                    const {
-                        code,
-                        timeout,
-                        readonly: readonlyMode,
-                    } = ExecuteCodeSchema.parse(params)
-
-                    // Security validation
-                    const security = getSecurityManager()
-                    const validation = security.validateCode(code)
-                    if (!validation.valid) {
-                        return {
-                            success: false,
-                            error: `Security validation failed: ${validation.errors.join('; ')}`,
-                        }
-                    }
-
-                    // Rate limiting
-                    if (!security.checkRateLimit('default')) {
-                        return {
-                            success: false,
-                            error: 'Rate limit exceeded (60 executions per minute)',
-                        }
-                    }
-
-                    // Build tool list (excluding codemode to prevent recursion)
-                    const allTools = collectNonCodeModeTools(context)
-
-                    // Filter out write operations if readonly mode
-                    const tools = readonlyMode
-                        ? allTools.filter((t) => t.annotations.readOnlyHint === true)
-                        : allTools
-
-                    // Build the API bridge
-                    const api = createJournalApi(tools)
-                    const bindings = api.createSandboxBindings()
-
-                    // Execute in sandbox (override timeout if specified)
-                    const pool = getSandboxPool()
-
-                    // For VM sandbox, the bindings are passed directly
-                    // For Worker sandbox, the bindings need to be the group API records
-                    return pool.execute(code, bindings, timeout).then((result) => {
-                        // Validate result size
-                        if (result.success && result.result !== undefined) {
-                            const sizeCheck = security.validateResultSize(result.result)
-                            if (!sizeCheck.valid) {
-                                return {
-                                    success: false,
-                                    error: sizeCheck.errors.join('; '),
-                                    metrics: result.metrics,
-                                }
-                            }
-                        }
-                        return result
-                    })
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-    ]
-}

package/src/handlers/tools/core.ts

@@ -1,359 +0,0 @@
-/**
- * Core Tool Group - 6 tools
- *
- * Tools: create_entry, get_entry_by_id, get_recent_entries,
- *        create_entry_minimal, test_simple, 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 { autoIndexEntry } from '../../utils/vector-index-helpers.js'
-import { resolveIssueUrl } from '../../utils/github-helpers.js'
-import { ErrorFieldsMixin } from './error-fields-mixin.js'
-import { logger } from '../../utils/logger.js'
-import {
-    ENTRY_TYPES,
-    SIGNIFICANCE_TYPES,
-    MAX_CONTENT_LENGTH,
-    EntryOutputSchema,
-    EntriesListOutputSchema,
-    RelationshipOutputSchema,
-    ImportanceBreakdownSchema,
-    relaxedNumber,
-    TagOutputSchema,
-} from './schemas.js'
-
-// ============================================================================
-// Input Schemas
-// ============================================================================
-
-/** Strict schema — used inside handler for structured Zod errors */
-const CreateEntrySchema = z.object({
-    content: z.string().min(1).max(MAX_CONTENT_LENGTH),
-    entry_type: z.enum(ENTRY_TYPES).optional().default('personal_reflection'),
-    tags: z.array(z.string()).optional().default([]),
-    is_personal: z.boolean().optional().default(true),
-    significance_type: z.enum(SIGNIFICANCE_TYPES).optional(),
-    auto_context: z.boolean().optional().default(true),
-    project_number: z.number().optional(),
-    project_owner: z.string().optional(),
-    issue_number: z.number().optional(),
-    issue_url: z.string().optional(),
-    pr_number: z.number().optional(),
-    pr_url: z.string().optional(),
-    pr_status: z.enum(['draft', 'open', 'merged', 'closed']).optional(),
-    workflow_run_id: z.number().optional(),
-    workflow_name: z.string().optional(),
-    workflow_status: z.enum(['queued', 'in_progress', 'completed']).optional(),
-    share_with_team: z.boolean().optional().default(false),
-})
-
-/** Relaxed schema — passed to SDK inputSchema so Zod enum errors reach the handler */
-const CreateEntrySchemaMcp = z.object({
-    content: z.string(),
-    entry_type: z.string().optional().default('personal_reflection'),
-    tags: z.array(z.string()).optional().default([]),
-    is_personal: z.boolean().optional().default(true),
-    significance_type: z.string().optional(),
-    auto_context: z.boolean().optional().default(true),
-    project_number: relaxedNumber().optional(),
-    project_owner: z.string().optional(),
-    issue_number: relaxedNumber().optional(),
-    issue_url: z.string().optional(),
-    pr_number: relaxedNumber().optional(),
-    pr_url: z.string().optional(),
-    pr_status: z.string().optional(),
-    workflow_run_id: relaxedNumber().optional(),
-    workflow_name: z.string().optional(),
-    workflow_status: z.string().optional(),
-    share_with_team: z.boolean().optional().default(false),
-})
-
-const GetEntryByIdSchema = z.object({
-    entry_id: z.number(),
-    include_relationships: z.boolean().optional().default(true),
-})
-
-/** Relaxed schema — passed to SDK inputSchema so type coercion errors reach the handler */
-const GetEntryByIdSchemaMcp = z.object({
-    entry_id: relaxedNumber(),
-    include_relationships: z.boolean().optional().default(true),
-})
-
-const GetRecentEntriesSchema = z.object({
-    limit: z.number().max(500).optional().default(5),
-    is_personal: z.boolean().optional(),
-})
-
-/** Relaxed schema — passed to SDK inputSchema so Zod min/max errors reach the handler */
-const GetRecentEntriesSchemaMcp = z.object({
-    limit: relaxedNumber().optional().default(5),
-    is_personal: z.boolean().optional(),
-})
-
-const CreateEntryMinimalSchema = z.object({
-    content: z.string().min(1).max(MAX_CONTENT_LENGTH),
-})
-
-/** Relaxed schema — passed to SDK inputSchema so Zod min/max errors reach the handler */
-const CreateEntryMinimalSchemaMcp = z.object({
-    content: z.string(),
-})
-
-const TestSimpleSchema = z.object({
-    message: z.string().optional().default('Hello'),
-})
-
-// ============================================================================
-// Output Schemas
-// ============================================================================
-
-const CreateEntryOutputSchema = z
-    .object({
-        success: z.boolean().optional(),
-        entry: EntryOutputSchema.optional(),
-        sharedWithTeam: z.boolean().optional(),
-        author: z.string().optional(),
-        error: z.string().optional(),
-    })
-    .extend(ErrorFieldsMixin.shape)
-
-const EntryByIdOutputSchema = z
-    .object({
-        entry: EntryOutputSchema.optional(),
-        relationships: z.array(RelationshipOutputSchema).optional(),
-        importance: z.number().nullable().optional(),
-        importanceBreakdown: ImportanceBreakdownSchema.optional(),
-        error: z.string().optional(),
-    })
-    .extend(ErrorFieldsMixin.shape)
-
-const TestSimpleOutputSchema = z
-    .object({
-        message: z.string(),
-    })
-    .extend(ErrorFieldsMixin.shape)
-
-const TagsListOutputSchema = z
-    .object({
-        tags: z.array(TagOutputSchema).optional(),
-        count: z.number().optional(),
-        success: z.boolean().optional(),
-        error: z.string().optional(),
-    })
-    .extend(ErrorFieldsMixin.shape)
-
-// ============================================================================
-// Tool Definitions
-// ============================================================================
-
-export function getCoreTools(context: ToolContext): ToolDefinition[] {
-    const { db, teamDb, vectorManager, github } = context
-    return [
-        {
-            name: 'create_entry',
-            title: 'Create Journal Entry',
-            description:
-                'Create a new journal entry with context and tags (v2.1.0: GitHub Actions support)',
-            group: 'core',
-            inputSchema: CreateEntrySchemaMcp,
-            outputSchema: CreateEntryOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    const input = CreateEntrySchema.parse(params)
-
-                    // Auto-populate issueUrl if issue_number provided without issueUrl
-                    const resolvedIssueUrl = resolveIssueUrl(
-                        github,
-                        input.issue_number,
-                        input.issue_url
-                    )
-
-                    const entry = db.createEntry({
-                        content: input.content,
-                        entryType: input.entry_type,
-                        tags: input.tags,
-                        isPersonal: input.is_personal,
-                        significanceType: input.significance_type ?? null,
-                        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,
-                        workflowRunId: input.workflow_run_id,
-                        workflowName: input.workflow_name,
-                        workflowStatus: input.workflow_status,
-                    })
-
-                    // Auto-index to vector store for semantic search (fire-and-forget)
-                    autoIndexEntry(vectorManager, entry.id, entry.content)
-
-                    // Share with team if requested
-                    let sharedWithTeam = false
-                    let author: string | undefined
-                    if (input.share_with_team && teamDb) {
-                        try {
-                            author = resolveAuthor()
-                            const teamEntry = 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,
-                                workflowRunId: input.workflow_run_id,
-                                workflowName: input.workflow_name,
-                                workflowStatus: input.workflow_status,
-                            })
-                            teamDb.executeRawQuery(
-                                'UPDATE memory_journal SET author = ? WHERE id = ?',
-                                [author, teamEntry.id]
-                            )
-                            teamDb.flushSave()
-                            sharedWithTeam = true
-                        } catch (error) {
-                            logger.debug('Failed to share entry with team DB', {
-                                module: 'TOOL',
-                                operation: 'create-entry',
-                                error,
-                            })
-                        }
-                    }
-
-                    return {
-                        success: true,
-                        entry,
-                        ...(sharedWithTeam ? { sharedWithTeam: true, author } : {}),
-                    }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'get_entry_by_id',
-            title: 'Get Entry by ID',
-            description: 'Get a specific journal entry by ID with full details',
-            group: 'core',
-            inputSchema: GetEntryByIdSchemaMcp,
-            outputSchema: EntryByIdOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    const { entry_id, include_relationships } = GetEntryByIdSchema.parse(params)
-                    const entry = db.getEntryById(entry_id)
-                    if (!entry) {
-                        return {
-                            success: false,
-                            error: `Entry ${String(entry_id)} not found`,
-                            code: 'RESOURCE_NOT_FOUND',
-                            category: 'resource',
-                            suggestion: 'Verify the entry ID and try again',
-                            recoverable: true,
-                        }
-                    }
-                    const { score: importance, breakdown: importanceBreakdown } =
-                        db.calculateImportance(entry_id)
-                    const result: Record<string, unknown> = {
-                        entry,
-                        importance,
-                        importanceBreakdown,
-                    }
-                    if (include_relationships) {
-                        result['relationships'] = db.getRelationships(entry_id)
-                    }
-                    return result
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'get_recent_entries',
-            title: 'Get Recent Entries',
-            description: 'Get recent journal entries',
-            group: 'core',
-            inputSchema: GetRecentEntriesSchemaMcp,
-            outputSchema: EntriesListOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    const { limit, is_personal } = GetRecentEntriesSchema.parse(params)
-                    const entries = db.getRecentEntries(limit, is_personal)
-                    return { entries, count: entries.length }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'create_entry_minimal',
-            title: 'Create Entry (Minimal)',
-            description: 'Minimal entry creation without context or tags',
-            group: 'core',
-            inputSchema: CreateEntryMinimalSchemaMcp,
-            outputSchema: CreateEntryOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    const { content } = CreateEntryMinimalSchema.parse(params)
-                    const entry = db.createEntry({ content })
-
-                    // Auto-index to vector store for semantic search (fire-and-forget)
-                    autoIndexEntry(vectorManager, entry.id, entry.content)
-
-                    return { success: true, entry }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'test_simple',
-            title: 'Test Simple',
-            description: 'Simple test tool that just returns a message',
-            group: 'core',
-            inputSchema: TestSimpleSchema,
-            outputSchema: TestSimpleOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-            handler: (params: unknown) => {
-                try {
-                    const { message } = TestSimpleSchema.parse(params)
-                    return { message: `Test response: ${message}` }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-        {
-            name: 'list_tags',
-            title: 'List Tags',
-            description: 'List all available tags',
-            group: 'core',
-            inputSchema: z.object({}).strict(),
-            outputSchema: TagsListOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-            handler: (_params: unknown) => {
-                try {
-                    const rawTags = db.listTags()
-                    const tags = rawTags.map((t) => ({ name: t.name, count: t.usageCount }))
-                    return { tags, count: tags.length }
-                } catch (err) {
-                    return formatHandlerError(err)
-                }
-            },
-        },
-    ]
-}

package/src/handlers/tools/error-fields-mixin.ts

@@ -1,10 +0,0 @@
-/**
- * Re-export stub — ErrorFieldsMixin has moved to its canonical location.
- *
- * SSoT: src/utils/errors/error-response-fields.ts
- *
- * This file exists for backward compatibility. New code should import
- * directly from '../../utils/errors/error-response-fields.js'.
- */
-
-export { ErrorFieldsMixin } from '../../utils/errors/error-response-fields.js'