@exaudeus/memory-mcp 0.1.0

package/dist/__tests__/config.test.js

@@ -0,0 +1,236 @@
+// Tests for config.ts — configuration loading with 3-tier fallback.
+// Tests the public API: getLobeConfigs() with different env/file setups.
+//
+// Strategy: We can't easily test file-based config (it reads relative to
+// the module), but we CAN test env-based and default-based config.
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { getLobeConfigs, parseBehaviorConfig } from '../config.js';
+// Save original env vars so we can restore after each test
+const originalEnv = {};
+const envKeys = [
+    'MEMORY_MCP_WORKSPACES',
+    'MEMORY_MCP_DIR',
+    'MEMORY_MCP_BUDGET',
+    'MEMORY_MCP_REPO_ROOT',
+];
+function saveEnv() {
+    for (const key of envKeys) {
+        originalEnv[key] = process.env[key];
+    }
+}
+function restoreEnv() {
+    for (const key of envKeys) {
+        if (originalEnv[key] === undefined) {
+            delete process.env[key];
+        }
+        else {
+            process.env[key] = originalEnv[key];
+        }
+    }
+}
+function clearConfigEnv() {
+    for (const key of envKeys) {
+        delete process.env[key];
+    }
+}
+describe('getLobeConfigs', () => {
+    let tempDir;
+    beforeEach(async () => {
+        saveEnv();
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'memory-mcp-config-test-'));
+    });
+    afterEach(async () => {
+        restoreEnv();
+        await fs.rm(tempDir, { recursive: true, force: true }).catch(() => { });
+    });
+    describe('env var config (tier 2)', () => {
+        it('loads from MEMORY_MCP_WORKSPACES json', () => {
+            clearConfigEnv();
+            process.env.MEMORY_MCP_WORKSPACES = JSON.stringify({
+                'my-repo': tempDir,
+            });
+            process.env.MEMORY_MCP_DIR = '.test-memory';
+            const { configs, origin } = getLobeConfigs();
+            // May load file config first if memory-config.json exists
+            // But if we're here, it should have at least one lobe
+            assert.ok(configs.size >= 1, 'Should have at least one lobe');
+            if (origin.source === 'env') {
+                const config = configs.get('my-repo');
+                assert.ok(config, 'Should have my-repo lobe');
+                assert.strictEqual(config.repoRoot, tempDir);
+                assert.ok(config.memoryPath.includes('.test-memory'), `Memory path should use MEMORY_MCP_DIR: ${config.memoryPath}`);
+            }
+        });
+        it('loads multiple lobes from env', () => {
+            clearConfigEnv();
+            const dir2 = tempDir + '-2';
+            process.env.MEMORY_MCP_WORKSPACES = JSON.stringify({
+                'repo-a': tempDir,
+                'repo-b': dir2,
+            });
+            const { configs, origin } = getLobeConfigs();
+            if (origin.source === 'env') {
+                assert.strictEqual(configs.size, 2, 'Should have 2 lobes');
+                assert.ok(configs.has('repo-a'));
+                assert.ok(configs.has('repo-b'));
+            }
+        });
+        it('respects custom budget from env', () => {
+            clearConfigEnv();
+            process.env.MEMORY_MCP_WORKSPACES = JSON.stringify({
+                'my-repo': tempDir,
+            });
+            process.env.MEMORY_MCP_BUDGET = String(5 * 1024 * 1024); // 5MB
+            const { configs, origin } = getLobeConfigs();
+            if (origin.source === 'env') {
+                const config = configs.get('my-repo');
+                assert.strictEqual(config.storageBudgetBytes, 5 * 1024 * 1024);
+            }
+        });
+        it('falls through on invalid MEMORY_MCP_WORKSPACES JSON', () => {
+            clearConfigEnv();
+            process.env.MEMORY_MCP_WORKSPACES = 'not valid json';
+            process.env.MEMORY_MCP_REPO_ROOT = tempDir;
+            // Should not throw — falls through to default
+            const { configs } = getLobeConfigs();
+            assert.ok(configs.size >= 1, 'Should fall through to at least one lobe');
+        });
+    });
+    describe('default fallback config (tier 3)', () => {
+        it('uses MEMORY_MCP_REPO_ROOT when no config file or env workspaces', () => {
+            clearConfigEnv();
+            process.env.MEMORY_MCP_REPO_ROOT = tempDir;
+            const { configs, origin } = getLobeConfigs();
+            // If there's no memory-config.json and no MEMORY_MCP_WORKSPACES,
+            // it should fall back to default
+            if (origin.source === 'default') {
+                assert.ok(configs.has('default'), 'Should have a default lobe');
+                assert.strictEqual(configs.get('default').repoRoot, tempDir);
+            }
+        });
+        it('uses cwd when no env vars at all', () => {
+            clearConfigEnv();
+            // No env vars set — should use process.cwd()
+            const { configs } = getLobeConfigs();
+            assert.ok(configs.size >= 1, 'Should always return at least one lobe');
+        });
+        it('uses explicit MEMORY_MCP_DIR for default lobe', () => {
+            clearConfigEnv();
+            process.env.MEMORY_MCP_REPO_ROOT = tempDir;
+            process.env.MEMORY_MCP_DIR = '.custom-memory';
+            const { configs, origin } = getLobeConfigs();
+            if (origin.source === 'default') {
+                const config = configs.get('default');
+                assert.ok(config.memoryPath.includes('.custom-memory'), `Should use custom dir: ${config.memoryPath}`);
+            }
+        });
+    });
+    describe('behavior config parsing', () => {
+        it('returns empty object when no behavior block provided', () => {
+            const result = parseBehaviorConfig(undefined);
+            // All fields should be absent (caller falls back to defaults from thresholds.ts)
+            assert.strictEqual(Object.keys(result).length, 0);
+        });
+        it('passes through valid values within allowed ranges', () => {
+            const result = parseBehaviorConfig({
+                staleDaysStandard: 14,
+                staleDaysPreferences: 60,
+                maxStaleInBriefing: 3,
+                maxDedupSuggestions: 5,
+                maxConflictPairs: 2,
+            });
+            assert.strictEqual(result.staleDaysStandard, 14);
+            assert.strictEqual(result.staleDaysPreferences, 60);
+            assert.strictEqual(result.maxStaleInBriefing, 3);
+            assert.strictEqual(result.maxDedupSuggestions, 5);
+            assert.strictEqual(result.maxConflictPairs, 2);
+        });
+        it('falls back to default for out-of-range staleDaysStandard', () => {
+            const tooLow = parseBehaviorConfig({ staleDaysStandard: 0 });
+            assert.strictEqual(tooLow.staleDaysStandard, 30, 'Should use default 30 for value below minimum (1)');
+            const tooHigh = parseBehaviorConfig({ staleDaysStandard: 500 });
+            assert.strictEqual(tooHigh.staleDaysStandard, 30, 'Should use default 30 for value above maximum (365)');
+        });
+        it('falls back to default for out-of-range staleDaysPreferences', () => {
+            const tooHigh = parseBehaviorConfig({ staleDaysPreferences: 800 });
+            assert.strictEqual(tooHigh.staleDaysPreferences, 90, 'Should use default 90 for value above maximum (730)');
+        });
+        it('falls back to default for out-of-range maxStaleInBriefing', () => {
+            const tooHigh = parseBehaviorConfig({ maxStaleInBriefing: 50 });
+            assert.strictEqual(tooHigh.maxStaleInBriefing, 5, 'Should use default 5 for value above maximum (20)');
+        });
+        it('falls back to default for out-of-range maxConflictPairs', () => {
+            const tooHigh = parseBehaviorConfig({ maxConflictPairs: 10 });
+            assert.strictEqual(tooHigh.maxConflictPairs, 2, 'Should use default 2 for value above maximum (5)');
+        });
+        it('rounds fractional values to integers', () => {
+            const result = parseBehaviorConfig({ staleDaysStandard: 14.7 });
+            assert.strictEqual(result.staleDaysStandard, 15, 'Should round to nearest integer');
+        });
+        it('handles partial behavior config — omitted fields do not appear', () => {
+            const result = parseBehaviorConfig({ staleDaysStandard: 14 });
+            assert.strictEqual(result.staleDaysStandard, 14);
+            // Omitted fields should not be set (callers use thresholds.ts defaults)
+            assert.strictEqual(result.staleDaysPreferences, 90, 'Non-omitted field uses default');
+        });
+        it('writes a stderr warning for unknown behavior config keys (typo detection)', () => {
+            const stderrWrites = [];
+            const origWrite = process.stderr.write.bind(process.stderr);
+            // Capture stderr
+            process.stderr.write = ((chunk, ...rest) => {
+                if (typeof chunk === 'string')
+                    stderrWrites.push(chunk);
+                return origWrite(chunk, ...rest);
+            });
+            try {
+                // "staleDaysStanderd" is a typo of "staleDaysStandard"
+                parseBehaviorConfig({ staleDaysStandard: 14, staleDaysStanderd: 7 });
+            }
+            finally {
+                process.stderr.write = origWrite;
+            }
+            const warnings = stderrWrites.filter(s => s.includes('Unknown behavior config key'));
+            assert.ok(warnings.length > 0, 'Should warn about unknown key "staleDaysStanderd"');
+            assert.ok(warnings[0].includes('staleDaysStanderd'), 'Warning should name the offending key');
+        });
+        it('does not warn for valid behavior config keys', () => {
+            const stderrWrites = [];
+            const origWrite = process.stderr.write.bind(process.stderr);
+            process.stderr.write = ((chunk, ...rest) => {
+                if (typeof chunk === 'string')
+                    stderrWrites.push(chunk);
+                return origWrite(chunk, ...rest);
+            });
+            try {
+                parseBehaviorConfig({ staleDaysStandard: 14, maxStaleInBriefing: 3 });
+            }
+            finally {
+                process.stderr.write = origWrite;
+            }
+            const unknownWarnings = stderrWrites.filter(s => s.includes('Unknown behavior config key'));
+            assert.strictEqual(unknownWarnings.length, 0, 'Should not warn for valid keys');
+        });
+    });
+    describe('config structure', () => {
+        it('all configs have required fields', () => {
+            // Use whatever config is currently active
+            const { configs } = getLobeConfigs();
+            for (const [name, config] of configs) {
+                assert.ok(config.repoRoot, `${name}: repoRoot should be set`);
+                assert.ok(config.memoryPath, `${name}: memoryPath should be set`);
+                assert.ok(config.storageBudgetBytes > 0, `${name}: storageBudgetBytes should be positive`);
+            }
+        });
+        it('origin is always a valid discriminated union', () => {
+            const { origin } = getLobeConfigs();
+            assert.ok(['file', 'env', 'default'].includes(origin.source), `Origin source should be file, env, or default: ${origin.source}`);
+            if (origin.source === 'file') {
+                assert.ok('path' in origin && typeof origin.path === 'string', 'File origin should have a path');
+            }
+        });
+    });
+});

package/dist/__tests__/crash-journal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/crash-journal.test.js

@@ -0,0 +1,203 @@
+// Tests for crash-journal.ts — crash report lifecycle: build, write, read, clear, format.
+// Uses real disk I/O with isolated temp directories — no mocks.
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { buildCrashReport, writeCrashReport, readLatestCrash, readCrashHistory, clearLatestCrash, formatCrashReport, formatCrashSummary, markServerStarted, } from '../crash-journal.js';
+// The crash journal writes to ~/.memory-mcp/crashes/ — we need to isolate tests.
+// We'll monkey-patch the module's internal CRASH_DIR by writing to a temp dir
+// and reading back. Since the module uses hardcoded paths, we test the public
+// API behaviors: buildCrashReport (pure), format functions (pure), and
+// read/write lifecycle (I/O — uses real paths, so we clean up carefully).
+describe('buildCrashReport', () => {
+    it('builds a report from an Error', () => {
+        markServerStarted();
+        const error = new Error('Test failure');
+        const context = {
+            phase: 'running',
+            lastToolCall: 'memory_store',
+            configSource: 'file',
+            lobeCount: 2,
+        };
+        const report = buildCrashReport(error, 'uncaught-exception', context);
+        assert.strictEqual(report.error, 'Test failure');
+        assert.ok(report.stack?.includes('Test failure'), 'Should include stack trace');
+        assert.strictEqual(report.type, 'uncaught-exception');
+        assert.strictEqual(report.context.phase, 'running');
+        assert.strictEqual(report.context.lastToolCall, 'memory_store');
+        assert.ok(report.timestamp, 'Should have ISO timestamp');
+        assert.ok(report.pid > 0, 'Should have process ID');
+        assert.ok(Array.isArray(report.recovery), 'Should have recovery steps');
+        assert.ok(report.recovery.length > 0, 'Should have at least one recovery step');
+    });
+    it('builds a report from a non-Error value', () => {
+        markServerStarted();
+        const report = buildCrashReport('string error', 'unknown', { phase: 'startup' });
+        assert.strictEqual(report.error, 'string error');
+        assert.strictEqual(report.stack, undefined, 'Non-Error has no stack');
+        assert.strictEqual(report.type, 'unknown');
+    });
+    it('includes server uptime', () => {
+        markServerStarted();
+        const report = buildCrashReport(new Error('test'), 'unknown', { phase: 'running' });
+        assert.ok(report.serverUptime >= 0, 'Uptime should be non-negative');
+    });
+    it('generates recovery steps for startup-failure', () => {
+        const report = buildCrashReport(new Error('Cannot read memory-config.json'), 'startup-failure', { phase: 'startup', configSource: 'file' });
+        assert.ok(report.recovery.some(s => s.includes('memory-config.json')), 'Should mention config file in recovery');
+    });
+    it('generates recovery steps for lobe-init-failure', () => {
+        const report = buildCrashReport(new Error('ENOENT: no such directory'), 'lobe-init-failure', { phase: 'startup', activeLobe: 'my-repo' });
+        assert.ok(report.recovery.some(s => s.includes('my-repo')), 'Should mention the failed lobe');
+    });
+    it('generates recovery steps for transport-error', () => {
+        const report = buildCrashReport(new Error('pipe broken'), 'transport-error', { phase: 'running' });
+        assert.ok(report.recovery.some(s => s.includes('toggle') || s.includes('Toggle')), 'Should suggest toggling MCP');
+    });
+    it('detects disk-full errors in recovery', () => {
+        const report = buildCrashReport(new Error('ENOSPC: no space left on device'), 'uncaught-exception', { phase: 'running' });
+        assert.ok(report.recovery.some(s => s.toLowerCase().includes('disk') || s.toLowerCase().includes('space')), 'Should mention disk space');
+    });
+    it('detects permission errors in recovery', () => {
+        const report = buildCrashReport(new Error('EACCES: permission denied'), 'uncaught-exception', { phase: 'running' });
+        assert.ok(report.recovery.some(s => s.toLowerCase().includes('permission')), 'Should mention permissions');
+    });
+});
+describe('formatCrashReport', () => {
+    const sampleReport = {
+        timestamp: '2026-01-15T10:30:00.000Z',
+        pid: 12345,
+        error: 'ENOENT: file not found',
+        stack: 'Error: ENOENT\n  at readFile (node:fs)\n  at Store.init (store.ts:42)',
+        type: 'startup-failure',
+        context: {
+            phase: 'startup',
+            lastToolCall: 'memory_bootstrap',
+            activeLobe: 'zillow',
+            configSource: 'file',
+            lobeCount: 3,
+        },
+        recovery: ['Check file permissions', 'Toggle MCP to restart'],
+        serverUptime: 0,
+    };
+    it('includes all key fields', () => {
+        const formatted = formatCrashReport(sampleReport);
+        assert.ok(formatted.includes('2026-01-15'), 'Should include timestamp');
+        assert.ok(formatted.includes('startup-failure'), 'Should include crash type');
+        assert.ok(formatted.includes('startup'), 'Should include phase');
+        assert.ok(formatted.includes('ENOENT'), 'Should include error message');
+        assert.ok(formatted.includes('memory_bootstrap'), 'Should include last tool call');
+        assert.ok(formatted.includes('zillow'), 'Should include affected lobe');
+    });
+    it('includes recovery steps', () => {
+        const formatted = formatCrashReport(sampleReport);
+        assert.ok(formatted.includes('Check file permissions'));
+        assert.ok(formatted.includes('Toggle MCP to restart'));
+    });
+    it('includes truncated stack trace', () => {
+        const formatted = formatCrashReport(sampleReport);
+        assert.ok(formatted.includes('Stack Trace'), 'Should have stack trace section');
+        assert.ok(formatted.includes('ENOENT'), 'Should include stack content');
+    });
+    it('omits stack trace section when absent', () => {
+        const noStack = { ...sampleReport, stack: undefined };
+        const formatted = formatCrashReport(noStack);
+        assert.ok(!formatted.includes('Stack Trace'), 'Should not have stack trace section');
+    });
+});
+describe('formatCrashSummary', () => {
+    it('formats a short summary with age', () => {
+        const report = {
+            timestamp: new Date(Date.now() - 5 * 60 * 1000).toISOString(), // 5 minutes ago
+            pid: 1,
+            error: 'Something broke unexpectedly during startup',
+            type: 'startup-failure',
+            context: { phase: 'startup' },
+            recovery: [],
+            serverUptime: 10,
+        };
+        const summary = formatCrashSummary(report);
+        assert.ok(summary.includes('5m ago') || summary.includes('4m ago'), 'Should show age in minutes');
+        assert.ok(summary.includes('startup-failure'), 'Should include type');
+        assert.ok(summary.includes('Something broke'), 'Should include error text');
+    });
+    it('truncates long error messages', () => {
+        const report = {
+            timestamp: new Date().toISOString(),
+            pid: 1,
+            error: 'A'.repeat(200),
+            type: 'unknown',
+            context: { phase: 'running' },
+            recovery: [],
+            serverUptime: 0,
+        };
+        const summary = formatCrashSummary(report);
+        assert.ok(summary.length < 250, 'Summary should be concise');
+    });
+});
+describe('crash report write/read lifecycle', () => {
+    // These tests use the real crash directory (~/.memory-mcp/crashes/)
+    // We write unique reports and clean them up after.
+    const testReports = [];
+    afterEach(async () => {
+        // Clean up test crash files
+        for (const report of testReports) {
+            const filename = `crash-${report.timestamp.replace(/[:.]/g, '-')}.json`;
+            const filepath = path.join(os.homedir(), '.memory-mcp', 'crashes', filename);
+            await fs.unlink(filepath).catch(() => { });
+        }
+        testReports.length = 0;
+        // Always clear LATEST.json to not interfere with real server
+        await clearLatestCrash();
+    });
+    it('writes and reads back a crash report', async () => {
+        markServerStarted();
+        const report = buildCrashReport(new Error('e2e test crash'), 'uncaught-exception', { phase: 'running' });
+        testReports.push(report);
+        const filepath = await writeCrashReport(report);
+        assert.ok(filepath.endsWith('.json'), 'Should write a .json file');
+        // Verify the file exists and is parseable
+        const content = await fs.readFile(filepath, 'utf-8');
+        const parsed = JSON.parse(content);
+        assert.strictEqual(parsed.error, 'e2e test crash');
+        assert.strictEqual(parsed.type, 'uncaught-exception');
+    });
+    it('readLatestCrash returns the most recent crash', async () => {
+        markServerStarted();
+        const report = buildCrashReport(new Error('latest test crash'), 'startup-failure', { phase: 'startup' });
+        testReports.push(report);
+        await writeCrashReport(report);
+        const latest = await readLatestCrash();
+        assert.ok(latest, 'Should find a latest crash');
+        assert.strictEqual(latest.error, 'latest test crash');
+    });
+    it('clearLatestCrash removes the latest indicator', async () => {
+        markServerStarted();
+        const report = buildCrashReport(new Error('to clear'), 'unknown', { phase: 'running' });
+        testReports.push(report);
+        await writeCrashReport(report);
+        await clearLatestCrash();
+        const latest = await readLatestCrash();
+        assert.strictEqual(latest, null, 'Should be null after clear');
+    });
+    it('readCrashHistory returns reports in reverse chronological order', async () => {
+        markServerStarted();
+        const report1 = buildCrashReport(new Error('crash-1'), 'unknown', { phase: 'running' });
+        // Small delay to ensure different timestamps
+        await new Promise(r => setTimeout(r, 10));
+        const report2 = buildCrashReport(new Error('crash-2'), 'unknown', { phase: 'running' });
+        testReports.push(report1, report2);
+        await writeCrashReport(report1);
+        await writeCrashReport(report2);
+        const history = await readCrashHistory(10);
+        assert.ok(history.length >= 2, 'Should have at least 2 reports');
+        // Most recent should be first
+        const idx1 = history.findIndex(r => r.error === 'crash-1');
+        const idx2 = history.findIndex(r => r.error === 'crash-2');
+        if (idx1 >= 0 && idx2 >= 0) {
+            assert.ok(idx2 < idx1, 'crash-2 (newer) should come before crash-1');
+        }
+    });
+});

package/dist/__tests__/e2e.test.d.ts

@@ -0,0 +1 @@
+export {};