memory-journal-mcp 6.1.2 → 6.2.1

package/test-server/test-filter-instructions.mjs

@@ -1,295 +0,0 @@
-/**
- * Filter-Aware Instruction Validation
- *
- * Starts the server with various --tool-filter configs and verifies that
- * each instruction section is correctly included or excluded based on enabled
- * tool groups. Also reports char counts and token estimates per configuration.
- *
- * Validated sections:
- *   CORE         — always present (Session Start, Behaviors, Rule & Skill Suggestions)
- *   COPILOT      — only when `github` group is enabled
- *   CODE_MODE    — only when `codemode` group is enabled
- *   GITHUB       — only when `github` group is enabled (standard+ level)
- *   SEARCH_ROW   — `semantic_search` Quick Access row only when `search` group enabled
- *
- * Usage:
- *   npm run build && node test-server/test-filter-instructions.mjs
- */
-
-import { spawn } from 'child_process'
-import { resolve, dirname } from 'path'
-import { fileURLToPath } from 'url'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const PROJECT_DIR = resolve(__dirname, '..')
-
-// Section markers — substrings we check for presence/absence in instructions
-const SECTIONS = {
-    CORE: 'Rule & Skill Suggestions', // Always present
-    COPILOT: 'Copilot Review Patterns', // github group only
-    CODE_MODE: 'Code Mode (Token-Efficient', // codemode group only
-    GITHUB_INTEGRATION: '## GitHub Integration', // github group, standard+ level
-    SEARCH_ROW: '| Semantic search |', // search group only
-}
-
-// Test matrix: each entry defines a filter config and expected section presence
-const TEST_CONFIGS = [
-    {
-        label: 'full (all groups)',
-        filter: null, // default
-        level: 'standard',
-        expect: {
-            CORE: true,
-            COPILOT: true,
-            CODE_MODE: true,
-            GITHUB_INTEGRATION: true,
-            SEARCH_ROW: true,
-        },
-    },
-    {
-        label: 'codemode only',
-        filter: 'codemode',
-        level: 'standard',
-        expect: {
-            CORE: true,
-            COPILOT: false,
-            CODE_MODE: true,
-            GITHUB_INTEGRATION: false,
-            SEARCH_ROW: false,
-        },
-    },
-    {
-        label: 'essential (core+codemode — no github)',
-        filter: 'essential',
-        level: 'standard',
-        // META_GROUPS.essential = ['core', 'codemode'] — no github, no search
-        expect: {
-            CORE: true,
-            COPILOT: false,
-            CODE_MODE: true,
-            GITHUB_INTEGRATION: false,
-            SEARCH_ROW: false,
-        },
-    },
-    {
-        label: 'starter (core+search+codemode — no github)',
-        filter: 'starter',
-        level: 'standard',
-        // META_GROUPS.starter = ['core', 'search', 'codemode']
-        expect: {
-            CORE: true,
-            COPILOT: false,
-            CODE_MODE: true,
-            GITHUB_INTEGRATION: false,
-            SEARCH_ROW: true,
-        },
-    },
-    {
-        label: 'core only (no codemode, no github, no search)',
-        filter: 'core',
-        level: 'standard',
-        expect: {
-            CORE: true,
-            COPILOT: false,
-            CODE_MODE: false,
-            GITHUB_INTEGRATION: false,
-            SEARCH_ROW: false,
-        },
-    },
-    {
-        label: 'full -codemode (github present, no code mode)',
-        filter: '-codemode',
-        level: 'standard',
-        expect: {
-            CORE: true,
-            COPILOT: true,
-            CODE_MODE: false,
-            GITHUB_INTEGRATION: true,
-            SEARCH_ROW: true,
-        },
-    },
-    {
-        label: 'full -github (no github, no copilot)',
-        filter: '-github',
-        level: 'standard',
-        expect: {
-            CORE: true,
-            COPILOT: false,
-            CODE_MODE: true,
-            GITHUB_INTEGRATION: false,
-            SEARCH_ROW: true,
-        },
-    },
-    {
-        label: 'readonly (core+search+analytics+relationships+export — no github, no codemode)',
-        filter: 'readonly',
-        level: 'standard',
-        // META_GROUPS.readonly excludes github and codemode groups
-        expect: {
-            CORE: true,
-            COPILOT: false,
-            CODE_MODE: false,
-            GITHUB_INTEGRATION: false,
-            SEARCH_ROW: true,
-        },
-    },
-    {
-        label: 'full — essential level (no github patterns even with github enabled)',
-        filter: null,
-        level: 'essential',
-        expect: {
-            CORE: true,
-            COPILOT: true,
-            CODE_MODE: true,
-            GITHUB_INTEGRATION: false,
-            SEARCH_ROW: true,
-        },
-    },
-]
-
-/** Spawn server with given filter/level, send initialize, capture instructions */
-function runConfig(filter, level) {
-    return new Promise((resolve, reject) => {
-        const args = ['dist/cli.js']
-        if (filter) args.push('--tool-filter', filter)
-        if (level) args.push('--instruction-level', level)
-
-        const proc = spawn('node', args, {
-            cwd: PROJECT_DIR,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        })
-
-        let buffer = ''
-
-        proc.stdout.on('data', (chunk) => {
-            buffer += chunk.toString()
-            const lines = buffer.split('\n')
-            for (const line of lines) {
-                const trimmed = line.trim()
-                if (!trimmed) continue
-                try {
-                    const msg = JSON.parse(trimmed)
-                    if (msg.id === 1 && msg.result) {
-                        const instructions =
-                            msg.result?.serverInfo?.instructions ||
-                            msg.result?.instructions ||
-                            msg.result?.capabilities?.instructions ||
-                            ''
-                        proc.kill()
-                        resolve(instructions)
-                    }
-                } catch {
-                    // Incomplete JSON, keep buffering
-                }
-            }
-        })
-
-        proc.stderr.on('data', () => {})
-
-        proc.stdin.write(
-            JSON.stringify({
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'initialize',
-                params: {
-                    protocolVersion: '2025-03-26',
-                    capabilities: {},
-                    clientInfo: { name: 'filter-instruction-test', version: '1.0' },
-                },
-            }) + '\n'
-        )
-
-        setTimeout(() => {
-            proc.kill()
-            reject(new Error('Timeout'))
-        }, 10000)
-    })
-}
-
-function tokenEstimate(text) {
-    return Math.round(text.length / 4)
-}
-
-function checkSections(instructions, expect) {
-    const results = {}
-    for (const [key, marker] of Object.entries(SECTIONS)) {
-        const present = instructions.includes(marker)
-        const shouldBePresent = expect[key]
-        results[key] = {
-            present,
-            expected: shouldBePresent,
-            pass: present === shouldBePresent,
-        }
-    }
-    return results
-}
-
-async function main() {
-    console.log('=== Filter-Aware Instruction Validation ===\n')
-    console.log('Checking that instruction sections are correctly included/excluded')
-    console.log('per enabled tool groups.\n')
-
-    let totalPassed = 0
-    let totalFailed = 0
-    const rows = []
-
-    for (const config of TEST_CONFIGS) {
-        process.stdout.write(`  Testing: ${config.label} ... `)
-        let instructions
-        try {
-            instructions = await runConfig(config.filter, config.level)
-        } catch (err) {
-            console.log(`❌ ERROR: ${err.message}`)
-            totalFailed++
-            continue
-        }
-
-        const chars = instructions.length
-        const tokens = tokenEstimate(instructions)
-        const sectionResults = checkSections(instructions, config.expect)
-
-        const failures = Object.entries(sectionResults).filter(([, r]) => !r.pass)
-        const allPass = failures.length === 0
-
-        if (allPass) {
-            console.log(`✅ (${chars} chars, ~${tokens} tokens)`)
-            totalPassed++
-        } else {
-            console.log(`❌ (${chars} chars, ~${tokens} tokens)`)
-            totalFailed++
-            for (const [section, result] of failures) {
-                const action = result.expected ? 'MISSING' : 'UNEXPECTED'
-                console.log(
-                    `      [${action}] ${section} — expected ${result.expected ? 'present' : 'absent'}, got ${result.present ? 'present' : 'absent'}`
-                )
-                console.log(`        marker: "${SECTIONS[section]}"`)
-            }
-        }
-
-        rows.push({ label: config.label, chars, tokens, pass: allPass, sectionResults })
-    }
-
-    // Token summary table
-    console.log('\n=== Token Estimates by Filter ===\n')
-    console.log(
-        `  ${'Filter'.padEnd(52)} ${'Chars'.padStart(6)} ${'~Tokens'.padStart(8)} ${'Sections'.padStart(30)}`
-    )
-    console.log(`  ${'-'.repeat(52)} ${'-'.repeat(6)} ${'-'.repeat(8)} ${'-'.repeat(30)}`)
-    for (const row of rows) {
-        const sectionSummary = Object.entries(row.sectionResults)
-            .map(([k, r]) => (r.present ? k.toLowerCase().replace('_', '-').slice(0, 5) : null))
-            .filter(Boolean)
-            .join('+')
-        console.log(
-            `  ${row.label.padEnd(52)} ${String(row.chars).padStart(6)} ${String(row.tokens).padStart(8)}   ${sectionSummary}`
-        )
-    }
-
-    console.log(`\n=== Results: ${totalPassed} passed, ${totalFailed} failed ===\n`)
-    process.exit(totalFailed > 0 ? 1 : 0)
-}
-
-main().catch((err) => {
-    console.error('Fatal:', err.message)
-    process.exit(1)
-})

package/test-server/test-instruction-levels.mjs

@@ -1,102 +0,0 @@
-/**
- * Phase 1.3A: Instruction Level Test
- *
- * Starts the server with each --instruction-level value (essential, standard, full)
- * and verifies that instruction text length increases across levels.
- *
- * Usage:
- *   node test-server/test-instruction-levels.mjs
- */
-
-import { spawn } from 'child_process'
-
-const PROJECT_DIR = 'C:\\Users\\chris\\Desktop\\memory-journal-mcp'
-const LEVELS = ['essential', 'standard', 'full']
-
-function testLevel(level) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn('node', ['dist/cli.js', '--instruction-level', level], {
-            cwd: PROJECT_DIR,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        })
-
-        let buffer = ''
-        proc.stdout.on('data', (chunk) => {
-            buffer += chunk.toString()
-            const lines = buffer.split('\n')
-            for (const line of lines) {
-                const trimmed = line.trim()
-                if (!trimmed) continue
-                try {
-                    const msg = JSON.parse(trimmed)
-                    if (msg.id === 1 && msg.result) {
-                        const instructions =
-                            msg.result?.serverInfo?.instructions || msg.result?.instructions || ''
-
-                        // Also check for the instructions field in capabilities
-                        const capInstructions = msg.result?.capabilities?.instructions || ''
-                        const text = instructions || capInstructions
-
-                        proc.kill()
-                        resolve({
-                            level,
-                            charCount: text.length,
-                            tokenEstimate: Math.round(text.length / 4),
-                        })
-                    }
-                } catch {
-                    // Not complete JSON yet
-                }
-            }
-        })
-
-        proc.stderr.on('data', () => {})
-
-        // Send initialize request
-        proc.stdin.write(
-            JSON.stringify({
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'initialize',
-                params: {
-                    protocolVersion: '2025-03-26',
-                    capabilities: {},
-                    clientInfo: { name: 'instruction-test', version: '1.0' },
-                },
-            }) + '\n'
-        )
-
-        setTimeout(() => {
-            proc.kill()
-            reject(new Error(`Timeout for level ${level}`))
-        }, 10000)
-    })
-}
-
-async function main() {
-    console.log('=== Phase 1.3A: Instruction Level Test ===\n')
-
-    const results = []
-    for (const level of LEVELS) {
-        const result = await testLevel(level)
-        results.push(result)
-        console.log(`  ${level}: ${result.charCount} chars (~${result.tokenEstimate} tokens)`)
-    }
-
-    // Verify ordering
-    const [essential, standard, full] = results
-    const orderCorrect =
-        essential.charCount < standard.charCount && standard.charCount < full.charCount
-
-    console.log(`\n  Order correct (essential < standard < full): ${orderCorrect ? '✅' : '❌'}`)
-    console.log(
-        `    ${essential.tokenEstimate} < ${standard.tokenEstimate} < ${full.tokenEstimate}`
-    )
-
-    process.exit(orderCorrect ? 0 : 1)
-}
-
-main().catch((err) => {
-    console.error('Fatal:', err.message)
-    process.exit(1)
-})

package/test-server/test-preflight.md

@@ -1,55 +0,0 @@
-# MCP Server Pre-Flight Check — memory-journal-mcp
-
-> **Purpose:** Validate that tiered instructions and resources are working correctly before running full test passes. Run this in a fresh conversation with the server enabled.
-
-Do NOT read any files from disk. Answer using ONLY what you received via MCP initialization and resource reads.
-
-## Step 1: Instructions Audit
-
-Report exactly what you received in the MCP server instructions during initialization:
-
-- Paste the FULL raw text you received (use a code block)
-- Character count of the instructions
-- Does it mention `memory://briefing`? (It should)
-- Does it contain Code Mode namespace reference (`mj.*`)? (It should at `essential` level)
-- What instruction tier does the content suggest? (essential ~2KB, standard ~3KB, full ~8KB)
-
-## Step 2: Resource Access
-
-Read `memory://briefing`. Report:
-
-- Did it succeed?
-- Does it contain a `userMessage` field?
-- What key sections are present? (entry counts, GitHub, milestones, etc.)
-
-Read `memory://health`. Report:
-
-- Did it succeed?
-- What database backend and tool filter status does it show?
-
-## Step 3: Instructions Resource
-
-Read `memory://instructions`. Report:
-
-- Did it succeed?
-- Approximate character count
-- Does it contain tool parameter tables? (It should — this is the full reference)
-- Is it significantly larger than the initialization instructions? (It should be)
-
-## Step 4: Tool Inventory
-
-List the tool groups you see and count of tools per group. Do NOT call any tools — just report what's in your tool list.
-
-## Step 5: Verdict
-
-Based on steps 1-4, answer:
-
-| #   | Check                                                                  | Result   |
-| --- | ---------------------------------------------------------------------- | -------- |
-| 1   | Initialization instructions are tiered (not the full 30KB reference)   | ✅ or ❌ |
-| 2   | Instructions mention `memory://briefing` as required first action      | ✅ or ❌ |
-| 3   | `memory://briefing` is readable and contains `userMessage`             | ✅ or ❌ |
-| 4   | `memory://health` is readable and shows server status                  | ✅ or ❌ |
-| 5   | `memory://instructions` contains the full reference (larger than init) | ✅ or ❌ |
-| 6   | Tool count matches expected for configured `--tool-filter`             | ✅ or ❌ |
-| 7   | No full parameter tables leaked into initialization instructions       | ✅ or ❌ |

package/test-server/test-prompts.mjs

@@ -1,185 +0,0 @@
-import { spawn } from 'child_process'
-import { join, dirname } from 'path'
-import { fileURLToPath } from 'url'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const projectDir = join(__dirname, '..')
-const proc = spawn('node', ['dist/cli.js', '--instruction-level', 'essential'], {
-    cwd: projectDir,
-    stdio: ['pipe', 'pipe', 'pipe'],
-})
-
-let buffer = ''
-const pending = new Map() // id -> resolve
-
-proc.stdout.on('data', (chunk) => {
-    buffer += chunk.toString()
-    const lines = buffer.split('\n')
-    buffer = lines.pop() // keep incomplete
-    for (const line of lines) {
-        const trimmed = line.trim()
-        if (!trimmed) continue
-        try {
-            const msg = JSON.parse(trimmed)
-            if (msg.id && pending.has(msg.id)) {
-                pending.get(msg.id)(msg)
-                pending.delete(msg.id)
-            }
-        } catch {}
-    }
-})
-proc.stderr.on('data', () => {})
-
-let nextId = 1
-function rpc(method, params = {}) {
-    const id = nextId++
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            pending.delete(id)
-            reject(new Error(`Timeout: ${method}`))
-        }, 20000)
-        pending.set(id, (msg) => {
-            clearTimeout(timer)
-            resolve(msg)
-        })
-        proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n')
-    })
-}
-function notify(method, params = {}) {
-    proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n')
-}
-
-const delay = (ms) => new Promise((r) => setTimeout(r, ms))
-
-async function main() {
-    // Initialize
-    await rpc('initialize', {
-        protocolVersion: '2025-03-26',
-        capabilities: {},
-        clientInfo: { name: 'test-prompts', version: '1.0' },
-    })
-    await delay(500)
-    notify('notifications/initialized')
-    await delay(1000)
-
-    // List prompts
-    const listResp = await rpc('prompts/list', {})
-    const prompts = listResp.result?.prompts ?? []
-    console.log(`\n=== PROMPTS LIST: ${prompts.length} prompts ===`)
-    for (const p of prompts) {
-        const args = (p.arguments || []).map((a) => `${a.name}${a.required ? '*' : ''}`).join(', ')
-        console.log(`  ${p.name}(${args})`)
-    }
-
-    const testCases = [
-        // 8.1 No-argument prompts
-        { name: 'prepare-standup', args: {}, expect: 'standup' },
-        { name: 'weekly-digest', args: {}, expect: 'weekly' },
-        { name: 'goal-tracker', args: {}, expect: 'goal' },
-        { name: 'get-context-bundle', args: {}, expect: 'context' },
-        { name: 'confirm-briefing', args: {}, expect: 'session' },
-        { name: 'session-summary', args: {}, expect: 'session' },
-        // 8.1 Required-argument prompts
-        { name: 'find-related', args: { query: 'architecture' }, expect: 'architecture' },
-        {
-            name: 'analyze-period',
-            args: { start_date: '2026-01-01', end_date: '2026-12-31' },
-            expect: '2026',
-        },
-        // 8.1 Optional-argument prompts
-        { name: 'prepare-retro', args: {}, expect: 'retrospective' },
-        { name: 'prepare-retro', args: { days: '7' }, expect: '7' },
-        { name: 'get-recent-entries', args: {}, expect: '' },
-        { name: 'get-recent-entries', args: { limit: '3' }, expect: '' },
-        // 8.2 GitHub prompts
-        { name: 'project-status-summary', args: { project_number: '5' }, expect: '5' },
-        { name: 'pr-summary', args: { pr_number: '67' }, expect: '67' },
-        { name: 'code-review-prep', args: { pr_number: '67' }, expect: '67' },
-        { name: 'pr-retrospective', args: { pr_number: '67' }, expect: '67' },
-        { name: 'project-milestone-tracker', args: { project_number: '5' }, expect: '5' },
-        { name: 'actions-failure-digest', args: {}, expect: '' },
-    ]
-
-    console.log(`\n=== TESTING ${testCases.length} PROMPT CALLS ===\n`)
-    let pass = 0,
-        fail = 0
-
-    for (const tc of testCases) {
-        const argsStr = Object.keys(tc.args).length ? JSON.stringify(tc.args) : '(none)'
-        try {
-            const resp = await rpc('prompts/get', { name: tc.name, arguments: tc.args })
-            if (resp.error) {
-                console.log(`FAIL ${tc.name}(${argsStr}): MCP error: ${JSON.stringify(resp.error)}`)
-                fail++
-                continue
-            }
-            const messages = resp.result?.messages
-            const checks = []
-            if (!Array.isArray(messages)) checks.push('messages not array')
-            else if (messages.length < 1) checks.push('messages empty')
-            else {
-                const m = messages[0]
-                if (m.role !== 'user') checks.push(`role=${m.role}`)
-                if (!m.content) checks.push('no content')
-                else {
-                    const c = m.content
-                    if (c.type !== 'text') checks.push(`type=${c.type}`)
-                    if (!c.text || c.text.length === 0) checks.push('text empty')
-                    else if (tc.expect && !c.text.toLowerCase().includes(tc.expect.toLowerCase())) {
-                        checks.push(`missing '${tc.expect}' (len=${c.text.length})`)
-                    }
-                }
-            }
-            if (checks.length === 0) {
-                const textLen = messages?.[0]?.content?.text?.length ?? 0
-                console.log(
-                    `PASS ${tc.name}(${argsStr}) — msgs:${messages.length}, textLen:${textLen}`
-                )
-                pass++
-            } else {
-                console.log(`FAIL ${tc.name}(${argsStr}): ${checks.join('; ')}`)
-                fail++
-            }
-        } catch (err) {
-            console.log(`FAIL ${tc.name}(${argsStr}): ${err.message}`)
-            fail++
-        }
-    }
-
-    // Error handling tests
-    try {
-        const resp = await rpc('prompts/get', { name: 'nonexistent-prompt', arguments: {} })
-        if (resp.error) {
-            console.log(`PASS nonexistent-prompt: MCP error (code=${resp.error.code})`)
-            pass++
-        } else {
-            console.log(`FAIL nonexistent-prompt: expected error`)
-            fail++
-        }
-    } catch (err) {
-        console.log(`FAIL nonexistent-prompt: ${err.message}`)
-        fail++
-    }
-
-    try {
-        const resp = await rpc('prompts/get', { name: 'find-related', arguments: {} })
-        if (resp.error) {
-            console.log(`PASS find-related(no args): error returned`)
-        } else {
-            console.log(`PASS find-related(no args): handled gracefully`)
-        }
-        pass++
-    } catch (err) {
-        console.log(`FAIL find-related(no args): ${err.message}`)
-        fail++
-    }
-
-    console.log(`\n=== RESULTS: ${pass} pass, ${fail} fail (${pass + fail} total) ===`)
-    proc.kill()
-    process.exit(fail > 0 ? 1 : 0)
-}
-
-main().catch((err) => {
-    console.error(err)
-    process.exit(1)
-})