@mndrk/memx 0.3.2 → 0.3.4

package/test/mcp.test.js

@@ -0,0 +1,288 @@
+/**
+ * Tests for MCP server (mcp.js)
+ */
+
+// Mock child_process before requiring module
+jest.mock('child_process', () => ({
+  spawnSync: jest.fn(() => ({
+    status: 0,
+    stdout: 'test output',
+    stderr: ''
+  }))
+}));
+
+const { MCPServer } = require('../mcp.js');
+const { spawnSync } = require('child_process');
+
+describe('MCPServer', () => {
+  let server;
+
+  beforeEach(() => {
+    server = new MCPServer('/test/dir');
+    spawnSync.mockClear();
+  });
+
+  describe('constructor', () => {
+    test('sets workDir from argument', () => {
+      const s = new MCPServer('/custom/path');
+      expect(s.workDir).toBe('/custom/path');
+    });
+
+    test('defaults to cwd if no argument', () => {
+      const s = new MCPServer();
+      expect(s.workDir).toBe(process.cwd());
+    });
+  });
+
+  describe('listTools', () => {
+    test('returns list of tools', () => {
+      const result = server.listTools();
+      expect(result).toHaveProperty('tools');
+      expect(Array.isArray(result.tools)).toBe(true);
+      expect(result.tools.length).toBeGreaterThan(0);
+    });
+
+    test('includes mem_context tool', () => {
+      const result = server.listTools();
+      const contextTool = result.tools.find(t => t.name === 'mem_context');
+      expect(contextTool).toBeDefined();
+      expect(contextTool.description).toContain('context');
+    });
+
+    test('includes mem_status tool', () => {
+      const result = server.listTools();
+      const statusTool = result.tools.find(t => t.name === 'mem_status');
+      expect(statusTool).toBeDefined();
+    });
+
+    test('includes mem_checkpoint tool', () => {
+      const result = server.listTools();
+      const checkpointTool = result.tools.find(t => t.name === 'mem_checkpoint');
+      expect(checkpointTool).toBeDefined();
+      expect(checkpointTool.inputSchema.required).toContain('message');
+    });
+
+    test('includes mem_learn tool', () => {
+      const result = server.listTools();
+      const learnTool = result.tools.find(t => t.name === 'mem_learn');
+      expect(learnTool).toBeDefined();
+      expect(learnTool.inputSchema.properties).toHaveProperty('insight');
+      expect(learnTool.inputSchema.properties).toHaveProperty('global');
+    });
+
+    test('includes mem_next tool', () => {
+      const result = server.listTools();
+      const nextTool = result.tools.find(t => t.name === 'mem_next');
+      expect(nextTool).toBeDefined();
+      expect(nextTool.inputSchema.required).toContain('step');
+    });
+
+    test('includes mem_stuck tool', () => {
+      const result = server.listTools();
+      const stuckTool = result.tools.find(t => t.name === 'mem_stuck');
+      expect(stuckTool).toBeDefined();
+    });
+
+    test('includes mem_goal tool', () => {
+      const result = server.listTools();
+      const goalTool = result.tools.find(t => t.name === 'mem_goal');
+      expect(goalTool).toBeDefined();
+    });
+
+    test('includes mem_tasks tool', () => {
+      const result = server.listTools();
+      const tasksTool = result.tools.find(t => t.name === 'mem_tasks');
+      expect(tasksTool).toBeDefined();
+    });
+
+    test('includes mem_switch tool', () => {
+      const result = server.listTools();
+      const switchTool = result.tools.find(t => t.name === 'mem_switch');
+      expect(switchTool).toBeDefined();
+      expect(switchTool.inputSchema.required).toContain('task');
+    });
+  });
+
+  describe('callTool', () => {
+    test('calls mem_context', () => {
+      spawnSync.mockReturnValue({ status: 0, stdout: 'context output', stderr: '' });
+      const result = server.callTool('mem_context', {});
+      expect(spawnSync).toHaveBeenCalledWith(
+        'mem',
+        ['context'],
+        expect.objectContaining({ cwd: '/test/dir' })
+      );
+      expect(result.success).toBe(true);
+      expect(result.output).toBe('context output');
+    });
+
+    test('calls mem_status', () => {
+      spawnSync.mockReturnValue({ status: 0, stdout: 'status output', stderr: '' });
+      const result = server.callTool('mem_status', {});
+      expect(spawnSync).toHaveBeenCalledWith(
+        'mem',
+        ['status'],
+        expect.objectContaining({ cwd: '/test/dir' })
+      );
+    });
+
+    test('calls mem_checkpoint with message', () => {
+      spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+      const result = server.callTool('mem_checkpoint', { message: 'Test checkpoint' });
+      expect(spawnSync).toHaveBeenCalledWith(
+        'mem',
+        ['checkpoint', 'Test checkpoint'],
+        expect.any(Object)
+      );
+    });
+
+    test('calls mem_learn with insight', () => {
+      spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+      const result = server.callTool('mem_learn', { insight: 'Test insight' });
+      expect(spawnSync).toHaveBeenCalledWith(
+        'mem',
+        ['learn', 'Test insight'],
+        expect.any(Object)
+      );
+    });
+
+    test('calls mem_learn with global flag', () => {
+      spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+      const result = server.callTool('mem_learn', { insight: 'Global insight', global: true });
+      expect(spawnSync).toHaveBeenCalledWith(
+        'mem',
+        ['learn', '-g', 'Global insight'],
+        expect.any(Object)
+      );
+    });
+
+    test('calls mem_next with step', () => {
+      spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+      server.callTool('mem_next', { step: 'Next step' });
+      expect(spawnSync).toHaveBeenCalledWith(
+        'mem',
+        ['next', 'Next step'],
+        expect.any(Object)
+      );
+    });
+
+    test('calls mem_stuck with reason', () => {
+      spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+      server.callTool('mem_stuck', { reason: 'Blocked reason' });
+      expect(spawnSync).toHaveBeenCalledWith(
+        'mem',
+        ['stuck', 'Blocked reason'],
+        expect.any(Object)
+      );
+    });
+
+    test('calls mem_goal to get current goal', () => {
+      spawnSync.mockReturnValue({ status: 0, stdout: 'Current goal', stderr: '' });
+      const result = server.callTool('mem_goal', {});
+      expect(spawnSync).toHaveBeenCalledWith(
+        'mem',
+        ['goal'],
+        expect.any(Object)
+      );
+    });
+
+    test('calls mem_goal to set new goal', () => {
+      spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+      server.callTool('mem_goal', { goal: 'New goal' });
+      expect(spawnSync).toHaveBeenCalledWith(
+        'mem',
+        ['goal', 'New goal'],
+        expect.any(Object)
+      );
+    });
+
+    test('calls mem_tasks', () => {
+      spawnSync.mockReturnValue({ status: 0, stdout: 'task list', stderr: '' });
+      server.callTool('mem_tasks', {});
+      expect(spawnSync).toHaveBeenCalledWith(
+        'mem',
+        ['tasks'],
+        expect.any(Object)
+      );
+    });
+
+    test('calls mem_switch with task name', () => {
+      spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+      server.callTool('mem_switch', { task: 'feature-branch' });
+      expect(spawnSync).toHaveBeenCalledWith(
+        'mem',
+        ['switch', 'feature-branch'],
+        expect.any(Object)
+      );
+    });
+
+    test('returns error for unknown tool', () => {
+      const result = server.callTool('unknown_tool', {});
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Unknown tool');
+    });
+
+    test('returns error when command fails', () => {
+      spawnSync.mockReturnValue({ status: 1, stdout: '', stderr: 'Command failed' });
+      const result = server.callTool('mem_status', {});
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Command failed');
+    });
+  });
+
+  describe('handleMessage', () => {
+    test('handles initialize method', () => {
+      const message = { id: 1, method: 'initialize', params: {} };
+      const response = server.handleMessage(message);
+      expect(response.jsonrpc).toBe('2.0');
+      expect(response.id).toBe(1);
+      expect(response.result.protocolVersion).toBe('2024-11-05');
+      expect(response.result.serverInfo.name).toBe('mem');
+    });
+
+    test('handles tools/list method', () => {
+      const message = { id: 2, method: 'tools/list', params: {} };
+      const response = server.handleMessage(message);
+      expect(response.id).toBe(2);
+      expect(response.result).toHaveProperty('tools');
+    });
+
+    test('handles tools/call method', () => {
+      spawnSync.mockReturnValue({ status: 0, stdout: 'Success', stderr: '' });
+      const message = {
+        id: 3,
+        method: 'tools/call',
+        params: { name: 'mem_status', arguments: {} }
+      };
+      const response = server.handleMessage(message);
+      expect(response.id).toBe(3);
+      expect(response.result.content[0].text).toBe('Success');
+      expect(response.result.isError).toBe(false);
+    });
+
+    test('handles tools/call with error', () => {
+      spawnSync.mockReturnValue({ status: 1, stdout: '', stderr: 'Failed' });
+      const message = {
+        id: 4,
+        method: 'tools/call',
+        params: { name: 'mem_status', arguments: {} }
+      };
+      const response = server.handleMessage(message);
+      expect(response.result.content[0].text).toContain('Error');
+      expect(response.result.isError).toBe(true);
+    });
+
+    test('handles notifications/initialized', () => {
+      const message = { method: 'notifications/initialized' };
+      const response = server.handleMessage(message);
+      expect(response).toBeNull();
+    });
+
+    test('handles unknown method', () => {
+      const message = { id: 5, method: 'unknown/method', params: {} };
+      const response = server.handleMessage(message);
+      expect(response.error.code).toBe(-32601);
+      expect(response.error.message).toContain('Method not found');
+    });
+  });
+});

package/test/more.test.js

@@ -0,0 +1,312 @@
+/**
+ * More tests to increase coverage towards 90%
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Mock child_process before requiring index.js
+jest.mock('child_process', () => ({
+  execSync: jest.fn(),
+  spawnSync: jest.fn(() => ({ status: 0, stdout: '', stderr: '' })),
+  spawn: jest.fn()
+}));
+
+// Mock readline
+jest.mock('readline', () => ({
+  createInterface: jest.fn(() => ({
+    question: jest.fn((q, cb) => cb('')),
+    close: jest.fn(),
+    on: jest.fn()
+  }))
+}));
+
+const {
+  loadConfig,
+  saveConfig,
+  loadIndex,
+  saveIndex,
+  findMemDir,
+  ensureTaskBranch,
+  parseFrontmatter,
+  serializeFrontmatter,
+  cmdStatus,
+  cmdGoal,
+  cmdNext,
+  cmdCheckpoint,
+  cmdLearn,
+  cmdLearnings,
+  cmdPromote,
+  cmdAppend,
+  cmdLog,
+  cmdHistory,
+  writeMemFile,
+  readMemFile,
+  CENTRAL_MEM,
+  CONFIG_DIR,
+  c,
+} = require('../index.js');
+
+const { spawnSync, execSync } = require('child_process');
+
+const testDir = path.join(os.tmpdir(), 'memx-test-more-' + Date.now());
+let memDir;
+
+beforeEach(() => {
+  memDir = path.join(testDir, '.mem');
+  fs.mkdirSync(memDir, { recursive: true });
+  fs.mkdirSync(path.join(memDir, '.git'), { recursive: true });
+  spawnSync.mockClear();
+  execSync.mockClear();
+  jest.spyOn(console, 'log').mockImplementation();
+});
+
+afterEach(() => {
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true });
+  }
+  jest.restoreAllMocks();
+});
+
+describe('loadConfig / saveConfig edge cases', () => {
+  test('loadConfig returns default for invalid JSON', () => {
+    // Cannot easily test due to fixed path, but verify function exists
+    expect(typeof loadConfig).toBe('function');
+  });
+
+  test('saveConfig creates directory if needed', () => {
+    expect(typeof saveConfig).toBe('function');
+  });
+});
+
+describe('loadIndex / saveIndex edge cases', () => {
+  test('saveIndex creates CENTRAL_MEM directory if needed', () => {
+    expect(typeof saveIndex).toBe('function');
+    expect(typeof loadIndex).toBe('function');
+  });
+});
+
+describe('findMemDir edge cases', () => {
+  test('returns null when no .mem found anywhere', () => {
+    const result = findMemDir('/nonexistent/path/that/does/not/exist');
+    // May return central mem or null depending on system
+    expect(result === null || typeof result === 'object').toBe(true);
+  });
+
+  test('finds local .mem over central', () => {
+    const localMem = path.join(testDir, '.mem');
+    fs.mkdirSync(path.join(localMem, '.git'), { recursive: true });
+
+    const result = findMemDir(testDir);
+    expect(result).not.toBeNull();
+    expect(result.isLocal).toBe(true);
+  });
+});
+
+describe('ensureTaskBranch edge cases', () => {
+  test('throws on branch checkout failure', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: 'main\n', stderr: '' })
+      .mockReturnValueOnce({ status: 1, stdout: '', stderr: 'branch not found' });
+
+    expect(() => ensureTaskBranch(memDir, 'task/nonexistent')).toThrow('branch not found');
+  });
+
+  test('does nothing when already on correct branch', () => {
+    spawnSync.mockReturnValueOnce({ status: 0, stdout: 'task/test\n', stderr: '' });
+
+    // Should not call checkout since we're already on the right branch
+    ensureTaskBranch(memDir, 'task/test');
+    expect(spawnSync).toHaveBeenCalledTimes(1);
+  });
+
+  test('does nothing when taskBranch is null', () => {
+    ensureTaskBranch(memDir, null);
+    expect(spawnSync).not.toHaveBeenCalled();
+  });
+});
+
+describe('parseFrontmatter edge cases', () => {
+  test('handles content with only body', () => {
+    const result = parseFrontmatter('Just body content');
+    expect(result.frontmatter).toEqual({});
+    expect(result.body).toBe('Just body content');
+  });
+
+  test('handles content with empty frontmatter', () => {
+    const result = parseFrontmatter('---\n\n---\n\nBody');
+    expect(result.frontmatter).toEqual({});
+    expect(result.body).toBe('Body');
+  });
+});
+
+describe('cmdStatus additional tests', () => {
+  test('shows goal line from body', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: 'task/test', stderr: '' });
+    writeMemFile(memDir, 'goal.md', `---
+task: test
+status: active
+---
+
+# Goal
+
+This is the goal line
+`);
+    writeMemFile(memDir, 'state.md', '---\nstatus: active\n---\n\n');
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdStatus(memDir);
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('This is the goal line');
+  });
+
+  test('shows status from frontmatter', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: 'task/test', stderr: '' });
+    writeMemFile(memDir, 'goal.md', `---
+task: test
+status: blocked
+---
+
+# Goal
+
+Test goal
+`);
+    writeMemFile(memDir, 'state.md', '---\nstatus: active\n---\n\n');
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdStatus(memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+});
+
+describe('cmdGoal additional tests', () => {
+  test('shows "No goal set" when file empty', () => {
+    writeMemFile(memDir, 'goal.md', '');
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdGoal([], memDir);
+    // Empty file should still output something
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+});
+
+describe('cmdNext additional tests', () => {
+  test('shows "No next step" when not set', () => {
+    writeMemFile(memDir, 'state.md', '---\nstatus: active\n---\n\n# State');
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdNext([], memDir);
+    expect(consoleSpy.mock.calls[0][0]).toContain('No next step');
+  });
+
+  test('adds Next Step section if not present', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    writeMemFile(memDir, 'state.md', '---\nstatus: active\n---\n\n# State');
+
+    cmdNext(['Do', 'something'], memDir);
+
+    const content = readMemFile(memDir, 'state.md');
+    expect(content).toContain('## Next Step');
+    expect(content).toContain('Do something');
+  });
+});
+
+describe('cmdCheckpoint additional tests', () => {
+  test('adds Checkpoints section if not present', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    writeMemFile(memDir, 'state.md', '---\nstatus: active\n---\n\n# State');
+
+    cmdCheckpoint(['Done', 'something'], memDir);
+
+    const content = readMemFile(memDir, 'state.md');
+    expect(content).toContain('## Checkpoints');
+  });
+});
+
+describe('cmdLearn additional tests', () => {
+  test('creates memory.md if not exists', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+
+    cmdLearn(['New', 'insight'], memDir);
+
+    const content = readMemFile(memDir, 'memory.md');
+    expect(content).toContain('New insight');
+  });
+
+  test('creates playbook.md if not exists', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+
+    cmdLearn(['-g', 'Global', 'insight'], memDir);
+
+    const content = readMemFile(memDir, 'playbook.md');
+    expect(content).toContain('Global insight');
+  });
+});
+
+describe('cmdLearnings additional tests', () => {
+  test('handles learnings without date prefix', () => {
+    writeMemFile(memDir, 'memory.md', '# Learnings\n\n- Simple learning without date');
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdLearnings([], memDir);
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Task Learnings');
+  });
+});
+
+describe('cmdPromote additional tests', () => {
+  test('creates playbook if not exists', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    writeMemFile(memDir, 'memory.md', '# Learnings\n\n- 2024-01-01: Test insight');
+
+    cmdPromote(['1'], memDir);
+
+    const content = readMemFile(memDir, 'playbook.md');
+    expect(content).toContain('Test insight');
+  });
+});
+
+describe('cmdAppend additional tests', () => {
+  test('appends to checkpoints using cmdCheckpoint', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    writeMemFile(memDir, 'state.md', '---\nstatus: active\n---\n\n## Checkpoints\n\n- [ ] Started');
+
+    cmdAppend(['checkpoints', 'New', 'checkpoint'], memDir);
+
+    const content = readMemFile(memDir, 'state.md');
+    expect(content).toContain('[x]'); // cmdCheckpoint adds [x] marker
+  });
+});
+
+describe('cmdLog additional tests', () => {
+  test('shows git log output', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: 'abc123 first commit\ndef456 second commit', stderr: '' });
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdLog(memDir);
+    expect(consoleSpy.mock.calls[0][0]).toContain('abc123');
+  });
+});
+
+describe('cmdHistory additional tests', () => {
+  test('shows history header', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: 'abc123 init', stderr: '' });
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdHistory(memDir);
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('History');
+  });
+});
+
+describe('color constants', () => {
+  test('all colors are defined', () => {
+    expect(c.reset).toBeDefined();
+    expect(c.bold).toBeDefined();
+    expect(c.dim).toBeDefined();
+    expect(c.green).toBeDefined();
+    expect(c.yellow).toBeDefined();
+    expect(c.blue).toBeDefined();
+    expect(c.cyan).toBeDefined();
+    expect(c.red).toBeDefined();
+    expect(c.magenta).toBeDefined();
+  });
+});