@mndrk/memx 0.3.2 → 0.3.4

package/test/init-local.test.js

@@ -0,0 +1,316 @@
+/**
+ * Tests for cmdInit local repo creation and cmdBranch central mem init
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Mock child_process
+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 { spawnSync, execSync } = require('child_process');
+
+const testDir = path.join(os.tmpdir(), 'memx-test-init-local-' + Date.now());
+const originalCwd = process.cwd;
+
+beforeEach(() => {
+  fs.mkdirSync(testDir, { recursive: true });
+  spawnSync.mockReset();
+  spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+  execSync.mockReset();
+  execSync.mockReturnValue('');
+  jest.spyOn(console, 'log').mockImplementation();
+  jest.spyOn(console, 'error').mockImplementation();
+});
+
+afterEach(() => {
+  process.cwd = originalCwd;
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true });
+  }
+  jest.restoreAllMocks();
+  jest.resetModules();
+});
+
+describe('cmdInit local repo creation', () => {
+  test('creates new local .mem repo', async () => {
+    // Mock cwd to return our test directory
+    const projectDir = path.join(testDir, 'project');
+    fs.mkdirSync(projectDir, { recursive: true });
+    process.cwd = jest.fn(() => projectDir);
+
+    jest.resetModules();
+    const { cmdInit } = require('../index.js');
+
+    await cmdInit(['test-task', 'Build', 'something'], null);
+
+    const output = console.log.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Created');
+  });
+
+  test('warns when .mem already exists locally', async () => {
+    const projectDir = path.join(testDir, 'existing-project');
+    fs.mkdirSync(path.join(projectDir, '.mem'), { recursive: true });
+    process.cwd = jest.fn(() => projectDir);
+
+    jest.resetModules();
+    const { cmdInit } = require('../index.js');
+
+    await cmdInit(['new-task'], null);
+
+    const output = console.log.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('already exists');
+  });
+
+  test('creates task with goal in new local repo', async () => {
+    const projectDir = path.join(testDir, 'new-project');
+    fs.mkdirSync(projectDir, { recursive: true });
+    process.cwd = jest.fn(() => projectDir);
+
+    jest.resetModules();
+    const { cmdInit } = require('../index.js');
+
+    await cmdInit(['feature', 'Add', 'new', 'feature'], null);
+
+    const output = console.log.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('feature');
+  });
+
+  test('handles git init failure', async () => {
+    const projectDir = path.join(testDir, 'fail-project');
+    fs.mkdirSync(projectDir, { recursive: true });
+    process.cwd = jest.fn(() => projectDir);
+
+    // Make execSync throw for git init
+    execSync.mockImplementation((cmd) => {
+      if (cmd && cmd.includes && cmd.includes('git init')) {
+        throw new Error('git init failed');
+      }
+      return '';
+    });
+
+    // Also make spawnSync fail for git commands
+    spawnSync.mockImplementation((cmd) => {
+      if (cmd === 'git') {
+        return { status: 1, stdout: '', stderr: 'git error' };
+      }
+      return { status: 0, stdout: '', stderr: '' };
+    });
+
+    jest.resetModules();
+    const { cmdInit } = require('../index.js');
+
+    await cmdInit(['fail-task'], null);
+
+    // Should handle error or succeed - just verify it ran
+    expect(console.log).toHaveBeenCalled();
+  });
+});
+
+describe('cmdBranch central mem initialization', () => {
+  test('initializes central mem when it does not exist', () => {
+    // Use a unique path for CENTRAL_MEM that doesn't exist
+    const uniqueCentralMem = path.join(testDir, 'central-mem-init-' + Date.now());
+
+    // We need to mock the module to use our test path
+    jest.resetModules();
+
+    // This is tricky - CENTRAL_MEM is a constant. Let's test the behavior instead.
+    const { cmdBranch, CENTRAL_MEM } = require('../index.js');
+
+    // Create a memDir that exists
+    const memDir = path.join(testDir, '.mem-test');
+    fs.mkdirSync(path.join(memDir, '.git'), { recursive: true });
+
+    cmdBranch(['new-branch'], memDir);
+
+    expect(console.log).toHaveBeenCalled();
+  });
+});
+
+describe('cmdCommit edge cases', () => {
+  test('shows warning when central mem does not exist', () => {
+    jest.resetModules();
+
+    const { cmdCommit, CENTRAL_MEM } = require('../index.js');
+
+    // Remove central mem if it exists
+    if (fs.existsSync(CENTRAL_MEM)) {
+      // We can't remove the real central mem, so just test with null memDir
+      cmdCommit(['test'], null);
+
+      const output = console.log.mock.calls.map(c => c[0]).join('\n');
+      // It should either show warning or use central mem
+      expect(console.log).toHaveBeenCalled();
+    } else {
+      cmdCommit(['test'], null);
+      expect(console.log).toHaveBeenCalled();
+    }
+  });
+});
+
+describe('interactiveInit edge cases', () => {
+  test('handles git init error in interactiveInit', async () => {
+    // This is tested indirectly through the module
+    jest.resetModules();
+
+    // Mock prompt responses
+    let promptIndex = 0;
+    const mockResponses = ['Test goal', 'Criterion 1', ''];
+
+    jest.doMock('readline', () => ({
+      createInterface: jest.fn(() => ({
+        question: jest.fn((q, cb) => {
+          cb(mockResponses[promptIndex++] || '');
+        }),
+        close: jest.fn(),
+        on: jest.fn()
+      }))
+    }));
+
+    execSync.mockImplementation((cmd) => {
+      if (cmd === 'git init') {
+        throw new Error('git init failed');
+      }
+      return '';
+    });
+
+    const { interactiveInit } = require('../index.js');
+
+    const result = await interactiveInit();
+
+    // Should handle error gracefully
+    expect(console.log).toHaveBeenCalled();
+  });
+});
+
+describe('startMCPServer', () => {
+  test('starts MCP server process', () => {
+    jest.resetModules();
+
+    // Create mock before requiring module
+    const mockChild = {
+      on: jest.fn((event, handler) => {
+        if (event === 'exit') {
+          setTimeout(() => handler(0), 10);
+        }
+        return mockChild;
+      })
+    };
+
+    jest.doMock('child_process', () => ({
+      execSync: jest.fn(),
+      spawnSync: jest.fn(() => ({ status: 0, stdout: '', stderr: '' })),
+      spawn: jest.fn(() => mockChild)
+    }));
+
+    const { startMCPServer, CENTRAL_MEM } = require('../index.js');
+
+    fs.mkdirSync(path.join(CENTRAL_MEM, '.git'), { recursive: true });
+
+    startMCPServer(['mcp']);
+
+    const { spawn } = require('child_process');
+    expect(spawn).toHaveBeenCalled();
+  });
+
+  test('handles MCP server spawn error', () => {
+    jest.resetModules();
+
+    const originalExit = process.exit;
+    process.exit = jest.fn();
+
+    const mockChild = {
+      on: jest.fn((event, handler) => {
+        if (event === 'error') {
+          setTimeout(() => handler(new Error('spawn failed')), 10);
+        }
+        return mockChild;
+      })
+    };
+
+    jest.doMock('child_process', () => ({
+      execSync: jest.fn(),
+      spawnSync: jest.fn(() => ({ status: 0, stdout: '', stderr: '' })),
+      spawn: jest.fn(() => mockChild)
+    }));
+
+    const { startMCPServer, CENTRAL_MEM } = require('../index.js');
+
+    fs.mkdirSync(path.join(CENTRAL_MEM, '.git'), { recursive: true });
+
+    startMCPServer(['mcp']);
+
+    // Wait for async error callback
+    return new Promise(resolve => {
+      setTimeout(() => {
+        expect(console.error).toHaveBeenCalled();
+        process.exit = originalExit;
+        resolve();
+      }, 50);
+    });
+  });
+});
+
+describe('findMemDir with central mem index', () => {
+  test('returns central mem with exact index match', () => {
+    jest.resetModules();
+
+    const { findMemDir, saveIndex, CENTRAL_MEM } = require('../index.js');
+
+    // Make sure central mem exists
+    fs.mkdirSync(path.join(CENTRAL_MEM, '.git'), { recursive: true });
+
+    // Save index with mapping
+    saveIndex({ '/exact/path': 'task/exact' });
+
+    const result = findMemDir('/exact/path');
+
+    expect(result).not.toBeNull();
+    expect(result.taskBranch).toBe('task/exact');
+  });
+
+  test('returns central mem with parent directory match', () => {
+    jest.resetModules();
+
+    const { findMemDir, saveIndex, CENTRAL_MEM } = require('../index.js');
+
+    fs.mkdirSync(path.join(CENTRAL_MEM, '.git'), { recursive: true });
+
+    // Save index with parent path mapping
+    saveIndex({ '/parent/path': 'task/parent' });
+
+    const result = findMemDir('/parent/path/child/subdir');
+
+    expect(result).not.toBeNull();
+    expect(result.taskBranch).toBe('task/parent');
+  });
+
+  test('returns unmapped when central exists but no mapping', () => {
+    jest.resetModules();
+
+    const { findMemDir, saveIndex, CENTRAL_MEM } = require('../index.js');
+
+    fs.mkdirSync(path.join(CENTRAL_MEM, '.git'), { recursive: true });
+    saveIndex({}); // Empty index
+
+    const result = findMemDir('/unmapped/path');
+
+    expect(result).not.toBeNull();
+    expect(result.unmapped).toBe(true);
+  });
+});

package/test/init.test.js

@@ -0,0 +1,122 @@
+/**
+ * Tests for initialization and task creation functions
+ */
+
+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 {
+  cmdInit,
+  cmdTasks,
+  writeMemFile,
+  readMemFile,
+  git,
+} = require('../index.js');
+
+const { spawnSync, execSync } = require('child_process');
+
+const testDir = path.join(os.tmpdir(), 'memx-test-init-' + 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('cmdInit', () => {
+  test('shows usage when name missing and no existing memDir', async () => {
+    const consoleSpy = jest.spyOn(console, 'log');
+    await cmdInit([], null);
+    // With no memDir and no name, it should show usage
+  });
+
+  test('creates task branch in existing repo', async () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+
+    await cmdInit(['new-task'], memDir);
+
+    expect(spawnSync).toHaveBeenCalledWith(
+      'git',
+      ['checkout', '-b', 'task/new-task'],
+      expect.any(Object)
+    );
+  });
+
+  test('creates task with goal', async () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+
+    await cmdInit(['my-task', 'Build', 'a', 'feature'], memDir);
+
+    // Should create files
+    expect(spawnSync).toHaveBeenCalledWith(
+      'git',
+      ['add', '-A'],
+      expect.any(Object)
+    );
+  });
+});
+
+describe('cmdTasks', () => {
+  test('prints warning when no memDir', () => {
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdTasks([], null);
+    expect(consoleSpy.mock.calls[0][0]).toContain('No .mem repo found');
+  });
+
+  test('shows no tasks when empty', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: 'main\n', stderr: '' }) // getCurrentBranch
+      .mockReturnValueOnce({ status: 0, stdout: '* main', stderr: '' }); // branch list
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdTasks([], memDir);
+    expect(consoleSpy.mock.calls[0][0]).toContain('No tasks');
+  });
+
+  test('lists tasks in non-TTY mode', () => {
+    // Mock process.stdin.isTTY to be false
+    Object.defineProperty(process.stdin, 'isTTY', { value: false, writable: true });
+
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: 'task/test\n', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '  main\n* task/test', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' });
+
+    writeMemFile(memDir, 'state.md', '---\nstatus: active\n---\n\n');
+    writeMemFile(memDir, 'goal.md', '# Goal\n\nTest\n\n## Progress: 50%');
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdTasks([], memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+});

package/test/interactive.test.js

@@ -0,0 +1,229 @@
+/**
+ * Tests for interactive async functions
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Variables for mock prompt responses - must be prefixed with 'mock'
+let mockPromptResponses = [];
+let mockPromptIndex = 0;
+
+// 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 with controlled responses
+jest.mock('readline', () => ({
+  createInterface: jest.fn(() => ({
+    question: jest.fn((q, cb) => {
+      const response = mockPromptResponses[mockPromptIndex] || '';
+      mockPromptIndex++;
+      cb(response);
+    }),
+    close: jest.fn(),
+    on: jest.fn()
+  }))
+}));
+
+const {
+  cmdDone,
+  interactiveInit,
+  setupRemote,
+  writeMemFile,
+  readMemFile,
+  CENTRAL_MEM,
+} = require('../index.js');
+
+const { spawnSync, execSync } = require('child_process');
+
+const testDir = path.join(os.tmpdir(), 'memx-test-interactive-' + 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();
+  mockPromptResponses = [];
+  mockPromptIndex = 0;
+  jest.spyOn(console, 'log').mockImplementation();
+});
+
+afterEach(() => {
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true });
+  }
+  jest.restoreAllMocks();
+});
+
+describe('cmdDone', () => {
+  test('shows warning when no memDir', async () => {
+    const consoleSpy = jest.spyOn(console, 'log');
+    await cmdDone(null);
+    expect(consoleSpy.mock.calls[0][0]).toContain('No .mem repo');
+  });
+
+  test('shows warning when on main branch', async () => {
+    spawnSync.mockReturnValueOnce({ status: 0, stdout: 'main', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    await cmdDone(memDir);
+    expect(consoleSpy.mock.calls[0][0]).toContain('Already on main');
+  });
+
+  test('completes task with no learnings to promote', async () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    spawnSync.mockReturnValueOnce({ status: 0, stdout: 'task/test', stderr: '' });
+
+    writeMemFile(memDir, 'memory.md', '# Learnings\n\n');
+
+    mockPromptResponses = ['none', 'n'];
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    await cmdDone(memDir);
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Completing task');
+  });
+
+  test('promotes learnings on done', async () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    spawnSync.mockReturnValueOnce({ status: 0, stdout: 'task/test', stderr: '' });
+
+    writeMemFile(memDir, 'memory.md', '# Learnings\n\n- 2024-01-01: First insight\n- 2024-01-02: Second insight');
+    writeMemFile(memDir, 'playbook.md', '# Playbook\n\n');
+
+    mockPromptResponses = ['1', 'n'];
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    await cmdDone(memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  test('deletes branch when requested', async () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    spawnSync.mockReturnValueOnce({ status: 0, stdout: 'task/test', stderr: '' });
+
+    writeMemFile(memDir, 'memory.md', '# Learnings\n\n');
+
+    mockPromptResponses = ['none', 'y'];
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    await cmdDone(memDir);
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Merged');
+  });
+
+  test('handles merge failure gracefully', async () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: 'task/test', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' })
+      .mockReturnValueOnce({ status: 1, stdout: '', stderr: 'merge conflict' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' });
+
+    writeMemFile(memDir, 'memory.md', '# Learnings\n\n');
+
+    mockPromptResponses = ['none'];
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    await cmdDone(memDir);
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Merge failed');
+  });
+});
+
+describe('interactiveInit', () => {
+  test('creates task from interactive input', async () => {
+    mockPromptResponses = [
+      'Build a feature',
+      'Users can login',
+      'Tests pass',
+      ''
+    ];
+
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    execSync.mockReturnValue('');
+
+    const result = await interactiveInit();
+
+    if (result) {
+      expect(result.name).toBe('build-a-feature');
+    }
+  });
+
+  test('handles empty goal input', async () => {
+    mockPromptResponses = [''];
+
+    const result = await interactiveInit();
+    expect(result).toBeNull();
+  });
+});
+
+describe('setupRemote', () => {
+  test('connects to existing remote', async () => {
+    mockPromptResponses = ['https://github.com/user/repo.git'];
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    await setupRemote(memDir, 'test-task');
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Connected');
+  });
+
+  test('handles remote connection failure', async () => {
+    mockPromptResponses = ['https://github.com/user/repo.git'];
+    spawnSync.mockReturnValueOnce({ status: 1, stdout: '', stderr: 'remote error' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    await setupRemote(memDir, 'test-task');
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Could not connect');
+  });
+
+  test('shows message when gh CLI not found', async () => {
+    mockPromptResponses = [''];
+    execSync.mockImplementation(() => { throw new Error('not found'); });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    await setupRemote(memDir, 'test-task');
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('GitHub CLI');
+  });
+
+  test('creates new repo with gh CLI', async () => {
+    mockPromptResponses = ['', 'my-repo', 'y'];
+    execSync.mockReturnValue('');
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    await setupRemote(memDir, 'test-task');
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Created repo');
+  });
+
+  test('handles gh repo create failure', async () => {
+    mockPromptResponses = ['', 'my-repo', 'n'];
+    execSync
+      .mockReturnValueOnce('')
+      .mockImplementationOnce(() => { throw new Error('gh error'); });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    await setupRemote(memDir, 'test-task');
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Could not create repo');
+  });
+});