@mndrk/memx 0.3.3 → 0.3.4

package/test/new.test.js

@@ -0,0 +1,175 @@
+/**
+ * Tests for cmdNew and related functions
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Track exit calls
+let mockExitCode = null;
+
+// 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 {
+  cmdNew,
+  writeMemFile,
+  readMemFile,
+  CENTRAL_MEM,
+  loadIndex,
+  saveIndex,
+} = require('../index.js');
+
+const { spawnSync, execSync } = require('child_process');
+
+const testDir = path.join(os.tmpdir(), 'memx-test-new-' + Date.now());
+let memDir;
+let originalExit;
+
+beforeEach(() => {
+  memDir = path.join(testDir, '.mem');
+  fs.mkdirSync(memDir, { recursive: true });
+  fs.mkdirSync(path.join(memDir, '.git'), { recursive: true });
+  spawnSync.mockClear();
+  execSync.mockClear();
+  mockExitCode = null;
+  originalExit = process.exit;
+  process.exit = jest.fn((code) => {
+    mockExitCode = code;
+    throw new Error(`process.exit(${code})`);
+  });
+  jest.spyOn(console, 'log').mockImplementation();
+});
+
+afterEach(() => {
+  process.exit = originalExit;
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true });
+  }
+  jest.restoreAllMocks();
+});
+
+describe('cmdNew', () => {
+  test('shows usage when no goal provided', () => {
+    const consoleSpy = jest.spyOn(console, 'log');
+
+    try {
+      cmdNew([], memDir);
+    } catch (e) {
+      expect(e.message).toContain('process.exit');
+    }
+
+    expect(mockExitCode).toBe(1);
+    expect(consoleSpy.mock.calls[0][0]).toContain('Usage');
+  });
+
+  test('shows JSON error when no goal in JSON mode', () => {
+    const consoleSpy = jest.spyOn(console, 'log');
+
+    try {
+      cmdNew(['--json'], memDir);
+    } catch (e) {
+      // expected
+    }
+
+    expect(mockExitCode).toBe(1);
+    const output = consoleSpy.mock.calls[0][0];
+    expect(output).toContain('error');
+  });
+
+  test('creates task with default provider', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdNew(['Build', 'a', 'feature'], memDir);
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Created task');
+    expect(output).toContain('build-a-feature');
+  });
+
+  test('creates task with custom provider', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdNew(['Build', 'something', '--provider', 'gemini'], memDir);
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('gemini');
+  });
+
+  test('creates task with -P flag', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdNew(['Test', 'task', '-P', 'ollama'], memDir);
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('ollama');
+  });
+
+  test('creates task with custom directory', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdNew(['My', 'task', '--dir', '/custom/path'], memDir);
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('/custom/path');
+  });
+
+  test('outputs JSON in JSON mode', () => {
+    spawnSync.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdNew(['--json', 'JSON', 'task'], memDir);
+
+    const output = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0];
+    const parsed = JSON.parse(output);
+    expect(parsed.taskName).toBe('json-task');
+    expect(parsed.goal).toBe('JSON task');
+  });
+
+  test('handles error gracefully', () => {
+    spawnSync.mockReturnValueOnce({ status: 1, stdout: '', stderr: 'git error' });
+
+    try {
+      cmdNew(['Failing', 'task'], memDir);
+    } catch (e) {
+      expect(e.message).toContain('process.exit');
+    }
+
+    expect(mockExitCode).toBe(1);
+  });
+
+  test('handles error in JSON mode', () => {
+    spawnSync.mockReturnValueOnce({ status: 1, stdout: '', stderr: 'git error' });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+
+    try {
+      cmdNew(['--json', 'Failing', 'task'], memDir);
+    } catch (e) {
+      // expected
+    }
+
+    expect(mockExitCode).toBe(1);
+    const output = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0];
+    const parsed = JSON.parse(output);
+    expect(parsed.error).toBeDefined();
+  });
+});

package/test/skill.test.js

@@ -0,0 +1,247 @@
+/**
+ * Tests for skill-related 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 {
+  isSkillInstalled,
+  installSkillTo,
+  handleSkillCommand,
+  MEM_SKILL
+} = require('../index.js');
+
+describe('MEM_SKILL constant', () => {
+  test('is defined', () => {
+    expect(MEM_SKILL).toBeDefined();
+    expect(typeof MEM_SKILL).toBe('string');
+  });
+
+  test('contains mem description', () => {
+    expect(MEM_SKILL).toContain('mem');
+    expect(MEM_SKILL).toContain('Persistent');
+  });
+
+  test('contains command examples', () => {
+    expect(MEM_SKILL).toContain('mem context');
+    expect(MEM_SKILL).toContain('mem checkpoint');
+    expect(MEM_SKILL).toContain('mem learn');
+  });
+});
+
+describe('isSkillInstalled', () => {
+  const testHome = path.join(os.tmpdir(), 'memx-test-skill-' + Date.now());
+
+  beforeEach(() => {
+    fs.mkdirSync(testHome, { recursive: true });
+    // Temporarily override HOME
+    process.env.ORIGINAL_HOME = process.env.HOME;
+    process.env.HOME = testHome;
+  });
+
+  afterEach(() => {
+    process.env.HOME = process.env.ORIGINAL_HOME;
+    delete process.env.ORIGINAL_HOME;
+    if (fs.existsSync(testHome)) {
+      fs.rmSync(testHome, { recursive: true });
+    }
+  });
+
+  test('returns false when skill not installed for claude', () => {
+    // Note: This test may be affected by the actual HOME directory
+    // Since we can't easily mock the path module's join behavior
+    const result = isSkillInstalled('claude');
+    expect(typeof result).toBe('boolean');
+  });
+
+  test('returns false when skill not installed for gemini', () => {
+    const result = isSkillInstalled('gemini');
+    expect(typeof result).toBe('boolean');
+  });
+
+  test('returns true when skill is installed', () => {
+    const skillDir = path.join(testHome, '.claude', 'skills', 'mem');
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), MEM_SKILL);
+
+    const result = isSkillInstalled('claude');
+    expect(result).toBe(true);
+  });
+});
+
+describe('installSkillTo', () => {
+  const testHome = path.join(os.tmpdir(), 'memx-test-install-' + Date.now());
+
+  beforeEach(() => {
+    fs.mkdirSync(testHome, { recursive: true });
+    process.env.ORIGINAL_HOME = process.env.HOME;
+    process.env.HOME = testHome;
+  });
+
+  afterEach(() => {
+    process.env.HOME = process.env.ORIGINAL_HOME;
+    delete process.env.ORIGINAL_HOME;
+    if (fs.existsSync(testHome)) {
+      fs.rmSync(testHome, { recursive: true });
+    }
+  });
+
+  test('creates skill directory for claude', () => {
+    const result = installSkillTo('claude');
+    expect(result).toContain('.claude');
+    expect(result).toContain('skills');
+    expect(result).toContain('mem');
+
+    const skillFile = path.join(result, 'SKILL.md');
+    expect(fs.existsSync(skillFile)).toBe(true);
+  });
+
+  test('creates skill directory for gemini', () => {
+    const result = installSkillTo('gemini');
+    expect(result).toContain('.gemini');
+    expect(result).toContain('skills');
+    expect(result).toContain('mem');
+
+    const skillFile = path.join(result, 'SKILL.md');
+    expect(fs.existsSync(skillFile)).toBe(true);
+  });
+
+  test('writes correct skill content', () => {
+    const result = installSkillTo('claude');
+    const skillFile = path.join(result, 'SKILL.md');
+    const content = fs.readFileSync(skillFile, 'utf8');
+    expect(content).toBe(MEM_SKILL);
+  });
+
+  test('overwrites existing skill file', () => {
+    // Install first time
+    const result = installSkillTo('claude');
+    const skillFile = path.join(result, 'SKILL.md');
+
+    // Modify the file
+    fs.writeFileSync(skillFile, 'old content');
+
+    // Install again
+    installSkillTo('claude');
+    const content = fs.readFileSync(skillFile, 'utf8');
+    expect(content).toBe(MEM_SKILL);
+  });
+});
+
+describe('handleSkillCommand', () => {
+  const testHome = path.join(os.tmpdir(), 'memx-test-handle-' + Date.now());
+  let consoleSpy;
+
+  beforeEach(() => {
+    fs.mkdirSync(testHome, { recursive: true });
+    process.env.ORIGINAL_HOME = process.env.HOME;
+    process.env.HOME = testHome;
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+  });
+
+  afterEach(() => {
+    process.env.HOME = process.env.ORIGINAL_HOME;
+    delete process.env.ORIGINAL_HOME;
+    if (fs.existsSync(testHome)) {
+      fs.rmSync(testHome, { recursive: true });
+    }
+    consoleSpy.mockRestore();
+  });
+
+  test('shows skill content with no subcommand', () => {
+    handleSkillCommand(['skill']);
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('/mem');
+    expect(output).toContain('LLM instructions');
+  });
+
+  test('shows skill content with "view" subcommand', () => {
+    handleSkillCommand(['skill', 'view']);
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('/mem');
+  });
+
+  test('shows skill content with "show" subcommand', () => {
+    handleSkillCommand(['skill', 'show']);
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('/mem');
+  });
+
+  test('installs to all providers with "install" subcommand', () => {
+    handleSkillCommand(['skill', 'install']);
+
+    const claudeSkill = path.join(testHome, '.claude', 'skills', 'mem', 'SKILL.md');
+    const geminiSkill = path.join(testHome, '.gemini', 'skills', 'mem', 'SKILL.md');
+
+    expect(fs.existsSync(claudeSkill)).toBe(true);
+    expect(fs.existsSync(geminiSkill)).toBe(true);
+  });
+
+  test('installs to all providers with "add" subcommand', () => {
+    handleSkillCommand(['skill', 'add']);
+
+    const claudeSkill = path.join(testHome, '.claude', 'skills', 'mem', 'SKILL.md');
+    expect(fs.existsSync(claudeSkill)).toBe(true);
+  });
+
+  test('installs to claude only with "install claude"', () => {
+    handleSkillCommand(['skill', 'install', 'claude']);
+
+    const claudeSkill = path.join(testHome, '.claude', 'skills', 'mem', 'SKILL.md');
+    const geminiSkill = path.join(testHome, '.gemini', 'skills', 'mem', 'SKILL.md');
+
+    expect(fs.existsSync(claudeSkill)).toBe(true);
+    expect(fs.existsSync(geminiSkill)).toBe(false);
+  });
+
+  test('installs to gemini only with "install gemini"', () => {
+    handleSkillCommand(['skill', 'install', 'gemini']);
+
+    const claudeSkill = path.join(testHome, '.claude', 'skills', 'mem', 'SKILL.md');
+    const geminiSkill = path.join(testHome, '.gemini', 'skills', 'mem', 'SKILL.md');
+
+    expect(fs.existsSync(claudeSkill)).toBe(false);
+    expect(fs.existsSync(geminiSkill)).toBe(true);
+  });
+
+  test('handles unknown target', () => {
+    handleSkillCommand(['skill', 'install', 'unknown']);
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Unknown target');
+  });
+
+  test('shows usage for unknown subcommand', () => {
+    handleSkillCommand(['skill', 'unknown']);
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('mem skill');
+    expect(output).toContain('Commands');
+  });
+
+  test('shows installed status when skills exist', () => {
+    // Pre-install
+    installSkillTo('claude');
+
+    handleSkillCommand(['skill']);
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('Installed');
+    expect(output).toContain('.claude');
+  });
+});

package/test/tasks-interactive.test.js

@@ -0,0 +1,243 @@
+/**
+ * Tests for cmdTasks - focus on list mode and testable parts
+ */
+
+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 {
+  cmdTasks,
+  writeMemFile,
+  readMemFile,
+  c
+} = require('../index.js');
+
+const { spawnSync } = require('child_process');
+
+const testDir = path.join(os.tmpdir(), 'memx-tasks-' + 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();
+  jest.spyOn(console, 'log').mockImplementation();
+  jest.spyOn(console, 'error').mockImplementation();
+});
+
+afterEach(() => {
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true });
+  }
+  jest.restoreAllMocks();
+});
+
+describe('cmdTasks list mode', () => {
+  test('shows message when no task branches', () => {
+    spawnSync.mockImplementation((cmd, args) => {
+      if (args && args.includes('--show-current')) {
+        return { status: 0, stdout: 'main', stderr: '' };
+      }
+      if (args && args[0] === 'branch' && args[1] === '-a') {
+        return { status: 0, stdout: '* main', stderr: '' };
+      }
+      return { status: 0, stdout: '', stderr: '' };
+    });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdTasks(['-l'], memDir);
+
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('No tasks');
+  });
+
+  test('lists active tasks with -l flag', () => {
+    // The first call is for --show-current, second for branch -a, etc.
+    spawnSync
+      .mockReturnValueOnce({ status: 0, stdout: 'task/feature', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '  main\n* task/feature\n  task/other', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '---\nstatus: active\n---\n\nTest goal', stderr: '' })
+      .mockReturnValueOnce({ status: 0, stdout: '---\nstatus: active\n---\n\nOther goal', stderr: '' });
+
+    writeMemFile(memDir, 'goal.md', '---\ntask: feature\nstatus: active\n---\n\n# Goal\n\nTest goal');
+    writeMemFile(memDir, 'state.md', '---\nstatus: active\n---\n\n');
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdTasks(['-l'], memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+    const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+    expect(output).toContain('feature');
+  });
+
+  test('shows done status with checkmark', () => {
+    spawnSync.mockImplementation((cmd, args) => {
+      if (args && args.includes('--show-current')) {
+        return { status: 0, stdout: 'main', stderr: '' };
+      }
+      if (args && args[0] === 'branch' && args[1] === '-a') {
+        return { status: 0, stdout: '* main\n  task/done-task', stderr: '' };
+      }
+      if (args && args[0] === 'show') {
+        return { status: 0, stdout: '---\nstatus: done\n---\n\nCompleted task', stderr: '' };
+      }
+      return { status: 0, stdout: '', stderr: '' };
+    });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdTasks(['-l'], memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  test('shows blocked status', () => {
+    spawnSync.mockImplementation((cmd, args) => {
+      if (args && args.includes('--show-current')) {
+        return { status: 0, stdout: 'main', stderr: '' };
+      }
+      if (args && args[0] === 'branch' && args[1] === '-a') {
+        return { status: 0, stdout: '* main\n  task/blocked-task', stderr: '' };
+      }
+      if (args && args[0] === 'show') {
+        return { status: 0, stdout: '---\nstatus: blocked\n---\n\nBlocked task', stderr: '' };
+      }
+      return { status: 0, stdout: '', stderr: '' };
+    });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdTasks(['-l'], memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  test('shows progress percentage', () => {
+    spawnSync.mockImplementation((cmd, args) => {
+      if (args && args.includes('--show-current')) {
+        return { status: 0, stdout: 'task/progress', stderr: '' };
+      }
+      if (args && args[0] === 'branch' && args[1] === '-a') {
+        return { status: 0, stdout: '* task/progress', stderr: '' };
+      }
+      if (args && args[0] === 'show') {
+        return { status: 0, stdout: '---\nstatus: active\n---\n\n## Progress: 50%', stderr: '' };
+      }
+      return { status: 0, stdout: '', stderr: '' };
+    });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdTasks(['-l'], memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  test('handles git show failure gracefully', () => {
+    spawnSync.mockImplementation((cmd, args) => {
+      if (args && args.includes('--show-current')) {
+        return { status: 0, stdout: 'main', stderr: '' };
+      }
+      if (args && args[0] === 'branch' && args[1] === '-a') {
+        return { status: 0, stdout: '  task/feature', stderr: '' };
+      }
+      if (args && args[0] === 'show') {
+        return { status: 1, stdout: '', stderr: 'not found' };
+      }
+      return { status: 0, stdout: '', stderr: '' };
+    });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdTasks(['-l'], memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  test('marks current task', () => {
+    spawnSync.mockImplementation((cmd, args) => {
+      if (args && args.includes('--show-current')) {
+        return { status: 0, stdout: 'task/current-one', stderr: '' };
+      }
+      if (args && args[0] === 'branch' && args[1] === '-a') {
+        return { status: 0, stdout: '* task/current-one\n  task/other', stderr: '' };
+      }
+      if (args && args[0] === 'show') {
+        return { status: 0, stdout: '---\nstatus: active\n---\n\n', stderr: '' };
+      }
+      return { status: 0, stdout: '', stderr: '' };
+    });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdTasks(['-l'], memDir);
+
+    // Verify the task is marked as current
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+});
+
+describe('cmdTasks non-interactive when stdin not TTY', () => {
+  test('falls back to list mode when stdin is not TTY', () => {
+    // Save original isTTY
+    const originalIsTTY = process.stdin.isTTY;
+    process.stdin.isTTY = false;
+
+    spawnSync.mockImplementation((cmd, args) => {
+      if (args && args.includes('--show-current')) {
+        return { status: 0, stdout: 'task/test', stderr: '' };
+      }
+      if (args && args[0] === 'branch' && args[1] === '-a') {
+        return { status: 0, stdout: '* task/test', stderr: '' };
+      }
+      if (args && args[0] === 'show') {
+        return { status: 0, stdout: '---\nstatus: active\n---\n\n', stderr: '' };
+      }
+      return { status: 0, stdout: '', stderr: '' };
+    });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdTasks([], memDir);
+
+    // Should show list output since stdin is not TTY
+    expect(consoleSpy).toHaveBeenCalled();
+
+    // Restore
+    process.stdin.isTTY = originalIsTTY;
+  });
+});
+
+describe('cmdTasks with remote branches', () => {
+  test('includes remote task branches', () => {
+    spawnSync.mockImplementation((cmd, args) => {
+      if (args && args.includes('--show-current')) {
+        return { status: 0, stdout: 'main', stderr: '' };
+      }
+      if (args && args[0] === 'branch' && args[1] === '-a') {
+        return { status: 0, stdout: '* main\n  remotes/origin/task/remote-feature', stderr: '' };
+      }
+      if (args && args[0] === 'show') {
+        return { status: 0, stdout: '---\nstatus: active\n---\n\n', stderr: '' };
+      }
+      return { status: 0, stdout: '', stderr: '' };
+    });
+
+    const consoleSpy = jest.spyOn(console, 'log');
+    cmdTasks(['-l'], memDir);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+});