@mndrk/memx 0.3.3 → 0.3.4

package/package.json

@@ -1,13 +1,32 @@
 {
   "name": "@mndrk/memx",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Persistent memory for AI agents - git-backed, branch-per-task, CLI interface",
   "main": "index.js",
   "bin": {
     "mem": "./index.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest --coverage",
+    "test:watch": "jest --watch"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "coverageThreshold": {
+      "global": {
+        "branches": 78,
+        "functions": 80,
+        "lines": 83,
+        "statements": 83
+      }
+    },
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "/test/"
+    ]
   },
   "keywords": [
     "ai",
@@ -23,5 +42,8 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/ramarlina/memx"
+  },
+  "devDependencies": {
+    "jest": "^30.2.0"
   }
 }

package/test/additional.test.js

@@ -0,0 +1,373 @@
+/**
+ * Additional tests to increase coverage
+ */
+
+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 {
+  cmdSwitch,
+  cmdSync,
+  cmdHistory,
+  cmdStuck,
+  cmdQuery,
+  cmdConstraint,
+  cmdProgress,
+  cmdCriteria,
+  cmdBranch,
+  cmdCommit,
+  writeMemFile,
+  readMemFile,
+  parseFrontmatter,
+  git,
+  getCurrentBranch,
+} = require('../index.js');
+
+const { spawnSync, execSync } = require('child_process');
+
+const testDir = path.join(os.tmpdir(), 'memx-test-additional-' + 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('cmdSwitch additional tests', () => {
+  test('tries without task/ prefix if first attempt fails', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 1, stdout: '', stderr: 'error' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' });
+
+    cmdSwitch(['main'], memDir);
+
+    expect(spawnSync).toHaveBeenCalledTimes(2);
+  });
+
+  test('handles both attempts failing', () => {
+    spawnSync.mockReturnValue({ status: 1, stdout: '', stderr: 'error' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdSwitch(['nonexistent'], memDir);
+
+    expect(consoleSpy.mock.calls.length).toBeGreaterThan(0);
+  });
+
+  test('handles task/ prefix in input', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    cmdSwitch(['task/feature'], memDir);
+    expect(spawnSync).toHaveBeenCalledWith(
+      'git',
+      ['checkout', 'task/feature'],
+      expect.any(Object)
+    );
+  });
+});
+
+describe('cmdSync additional tests', () => {
+  test('handles sync with remote', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: 'origin', stderr: '' }) // git remote
+      .mockReturnValueOnce({ status: 0, stdout: 'task/test', stderr: '' }) // getCurrentBranch
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' }) // pull
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' }); // push
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdSync(memDir);
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Syncing');
+  });
+
+  test('handles pull failure gracefully', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: 'origin', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: 'task/test', stderr: '' })
+      .mockReturnValueOnce({ status: 1, stdout: '', stderr: 'pull error' }) // pull fails
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' }); // push
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdSync(memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  test('handles push failure', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: 'origin', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: 'task/test', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' })
+      .mockReturnValueOnce({ status: 1, stdout: '', stderr: 'push error' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdSync(memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+});
+
+describe('cmdStuck additional tests', () => {
+  test('shows existing blocker', () => {
+    writeMemFile(memDir, 'state.md', '---\nstatus: blocked\nblocker: Waiting for review\n---\n\n');
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdStuck([], memDir);
+    expect(consoleSpy.mock.calls[0][0]).toContain('Waiting for review');
+  });
+});
+
+describe('cmdQuery additional tests', () => {
+  test('shows results from grep', () => {
+    execSync.mockReturnValue('goal.md:3:Test result');
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdQuery(['test'], memDir);
+    expect(consoleSpy.mock.calls[0][0]).toContain('Test result');
+  });
+
+  test('handles no results', () => {
+    execSync.mockImplementation(() => { throw new Error('no matches'); });
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdQuery(['nonexistent'], memDir);
+    expect(consoleSpy.mock.calls[0][0]).toContain('No matches');
+  });
+});
+
+describe('cmdConstraint additional tests', () => {
+  test('lists existing constraints', () => {
+    writeMemFile(memDir, 'goal.md', `# Goal
+
+## Constraints
+
+- No breaking changes
+- Test coverage > 80%
+`);
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdConstraint([], memDir);
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Constraints');
+  });
+
+  test('shows no constraints message', () => {
+    writeMemFile(memDir, 'goal.md', '# Goal\n\n## Constraints\n\n');
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdConstraint([], memDir);
+    expect(consoleSpy.mock.calls[0][0]).toContain('No constraints');
+  });
+
+  test('removes constraint by number', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    writeMemFile(memDir, 'goal.md', `# Goal
+
+## Constraints
+
+- First constraint
+- Second constraint
+`);
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdConstraint(['remove', '1'], memDir);
+
+    const content = readMemFile(memDir, 'goal.md');
+    expect(content).not.toContain('First constraint');
+  });
+
+  test('shows usage for unknown subcommand', () => {
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdConstraint(['unknown'], memDir);
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('mem constraint');
+  });
+});
+
+describe('cmdProgress additional tests', () => {
+  test('shows message when no criteria defined', () => {
+    writeMemFile(memDir, 'goal.md', `# Goal
+
+Test
+
+## Definition of Done
+
+`);
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdProgress([], memDir);
+    expect(consoleSpy.mock.calls[0][0]).toContain('No criteria');
+  });
+
+  test('updates progress percentage in file', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    writeMemFile(memDir, 'goal.md', `# Goal
+
+Test
+
+## Definition of Done
+
+- [x] First
+- [x] Second
+- [x] Third
+
+## Progress: 0%
+`);
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdProgress([], memDir);
+
+    const content = readMemFile(memDir, 'goal.md');
+    expect(content).toContain('100%');
+  });
+
+  test('handles goal.md not found', () => {
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdProgress([], memDir);
+    expect(consoleSpy.mock.calls[0][0]).toContain('No goal.md');
+  });
+});
+
+describe('cmdCriteria additional tests', () => {
+  test('shows usage when no args', () => {
+    writeMemFile(memDir, 'goal.md', '# Goal\n\n## Definition of Done\n\n- [ ] Test');
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdCriteria([], memDir);
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('mem criteria');
+  });
+
+  test('marks criterion complete with check subcommand', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    writeMemFile(memDir, 'goal.md', `# Goal
+
+## Definition of Done
+
+- [ ] First
+- [ ] Second
+
+## Progress: 0%
+`);
+    cmdCriteria(['check', '1'], memDir);
+
+    const content = readMemFile(memDir, 'goal.md');
+    expect(content).toContain('- [x] First');
+  });
+
+  test('handles goal.md not found', () => {
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdCriteria(['add', 'Test'], memDir);
+    expect(consoleSpy.mock.calls[0][0]).toContain('No goal.md');
+  });
+});
+
+describe('cmdBranch additional tests', () => {
+  test('switches to existing branch', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: '  main\n  task/existing', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdBranch(['existing'], memDir);
+
+    expect(spawnSync).toHaveBeenCalledWith(
+      'git',
+      ['checkout', 'task/existing'],
+      expect.any(Object)
+    );
+  });
+
+  test('handles branch operation error', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: '  main', stderr: '' })
+      .mockReturnValueOnce({ status: 1, stdout: '', stderr: 'error' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdBranch(['new-branch'], memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  test('handles task/ prefix in branch name', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: '  main', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' });
+
+    cmdBranch(['task/my-feature'], memDir);
+
+    expect(spawnSync).toHaveBeenCalledWith(
+      'git',
+      ['checkout', '-b', 'task/my-feature'],
+      expect.any(Object)
+    );
+  });
+});
+
+describe('cmdCommit additional tests', () => {
+  test('uses default message when none provided', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: 'M file.md', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' });
+
+    cmdCommit([], memDir);
+
+    expect(spawnSync).toHaveBeenCalledWith(
+      'git',
+      ['commit', '-m', 'checkpoint'],
+      expect.any(Object)
+    );
+  });
+
+  test('handles commit error', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: 'M file.md', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' })
+      .mockReturnValueOnce({ status: 1, stdout: '', stderr: 'commit failed' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdCommit(['test'], memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+});
+
+describe('git helper additional tests', () => {
+  test('handles git error with empty stderr', () => {
+    spawnSync.mockReturnValue({ status: 1, stdout: '', stderr: '' });
+    expect(() => git(memDir, 'status')).toThrow('Git command failed');
+  });
+
+  test('handles null stdout', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: null, stderr: '' });
+    const result = git(memDir, 'status');
+    expect(result).toBe('');
+  });
+});
+
+describe('getCurrentBranch', () => {
+  test('returns branch name', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: 'main\n', stderr: '' });
+    const result = getCurrentBranch(memDir);
+    expect(result).toBe('main');
+  });
+});

package/test/branches.test.js

@@ -0,0 +1,247 @@
+/**
+ * Tests for branch coverage
+ */
+
+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,
+  cmdConstraint,
+  cmdProgress,
+  cmdCriteria,
+  cmdBranch,
+  cmdCommit,
+  cmdSwitch,
+  cmdSync,
+  writeMemFile,
+  readMemFile,
+  CENTRAL_MEM,
+  loadIndex,
+  saveIndex,
+} = require('../index.js');
+
+const { spawnSync, execSync } = require('child_process');
+
+const testDir = path.join(os.tmpdir(), 'memx-test-branches-' + 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 edge cases', () => {
+  test('handles branch creation error', async () => {
+    spawnSync.mockReturnValueOnce({ status: 1, stdout: '', stderr: 'branch exists' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    await cmdInit(['existing-task'], memDir);
+
+    expect(consoleSpy.mock.calls[0][0]).toContain('Error');
+  });
+
+  test('creates task with goal in existing repo', async () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    await cmdInit(['my-task', 'Build', 'something'], memDir);
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Created task branch');
+    expect(output).toContain('Build something');
+  });
+
+  test('shows usage when no name provided with existing memDir', async () => {
+    const consoleSpy = jest.spyOn(console, 'log');
+    await cmdInit([], memDir);
+
+    expect(consoleSpy.mock.calls[0][0]).toContain('Usage');
+  });
+});
+
+describe('cmdConstraint edge cases', () => {
+  test('shows constraint not found for invalid number', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    writeMemFile(memDir, 'goal.md', `# Goal\n\n## Constraints\n\n- First\n- Second`);
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdConstraint(['remove', '99'], memDir);
+
+    expect(consoleSpy.mock.calls[0][0]).toContain('not found');
+  });
+
+  test('adds constraint to new section', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    writeMemFile(memDir, 'goal.md', `# Goal\n\nTest goal`);
+
+    cmdConstraint(['add', 'New constraint'], memDir);
+
+    const content = readMemFile(memDir, 'goal.md');
+    expect(content).toContain('## Constraints');
+    expect(content).toContain('New constraint');
+  });
+});
+
+describe('cmdProgress edge cases', () => {
+  test('shows warning when no Definition of Done section', () => {
+    writeMemFile(memDir, 'goal.md', `# Goal\n\nJust a goal without criteria`);
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdProgress([], memDir);
+
+    expect(consoleSpy.mock.calls[0][0]).toContain('No "Definition of Done"');
+  });
+
+  test('shows progress with mixed criteria', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    writeMemFile(memDir, 'goal.md', `# Goal
+
+Test goal
+
+## Definition of Done
+
+- [x] First done
+- [ ] Second not done
+- [x] Third done
+
+## Progress: 0%`);
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdProgress([], memDir);
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    // Should show 66% (2 of 3)
+    expect(output).toMatch(/66%|67%/);
+  });
+});
+
+describe('cmdCriteria edge cases', () => {
+  test('checks criterion by number', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    writeMemFile(memDir, 'goal.md', `# Goal
+
+## Definition of Done
+
+- [ ] First
+- [ ] Second
+- [ ] Third
+
+## Progress: 0%`);
+
+    cmdCriteria(['check', '2'], memDir);
+
+    const content = readMemFile(memDir, 'goal.md');
+    expect(content).toContain('- [ ] First');
+    expect(content).toContain('- [x] Second');
+    expect(content).toContain('- [ ] Third');
+  });
+
+  test('adds criterion with add command', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+    writeMemFile(memDir, 'goal.md', `# Goal
+
+## Definition of Done
+
+- [ ] First
+
+## Progress: 0%`);
+
+    cmdCriteria(['add', 'New', 'criterion'], memDir);
+
+    const content = readMemFile(memDir, 'goal.md');
+    expect(content).toContain('New criterion');
+  });
+});
+
+describe('cmdBranch edge cases', () => {
+  test('lists branches when no args', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '  main\n* task/test', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdBranch([], memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  test('creates branch with task/ prefix already present', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: '  main', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdBranch(['task/already-prefixed'], memDir);
+
+    expect(spawnSync).toHaveBeenCalledWith(
+      'git',
+      ['checkout', '-b', 'task/already-prefixed'],
+      expect.any(Object)
+    );
+  });
+});
+
+describe('cmdCommit edge cases', () => {
+  test('shows warning when nothing to commit', () => {
+    spawnSync.mockReturnValueOnce({ status: 0, stdout: '', stderr: '' }); // git status shows nothing
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdCommit(['test message'], memDir);
+
+    expect(consoleSpy.mock.calls[0][0]).toContain('No changes');
+  });
+
+  test('commits with custom message', () => {
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: 'M file.md', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdCommit(['Custom', 'commit', 'message'], memDir);
+
+    expect(spawnSync).toHaveBeenCalledWith(
+      'git',
+      ['commit', '-m', 'Custom commit message'],
+      expect.any(Object)
+    );
+  });
+});
+
+describe('cmdSync edge cases', () => {
+  test('shows warning when no remote', () => {
+    spawnSync.mockReturnValueOnce({ status: 0, stdout: '', stderr: '' }); // no remote
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdSync(memDir);
+
+    expect(consoleSpy.mock.calls[0][0]).toContain('No remote');
+  });
+});