evomap__evolver/test/adapters.test.js

const { describe, it } = require('node:test');
const assert = require('node:assert/strict');
const path = require('path');
const fs = require('fs');
const os = require('os');

const hookAdapter = require('../src/adapters/hookAdapter');
const cursorAdapter = require('../src/adapters/cursor');
const claudeAdapter = require('../src/adapters/claudeCode');
const codexAdapter = require('../src/adapters/codex');

function makeTmpDir() {
  return fs.mkdtempSync(path.join(os.tmpdir(), 'evolver-hooks-test-'));
}

function cleanup(dir) {
  try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
}

// -- hookAdapter --

describe('hookAdapter', () => {
  describe('detectPlatform', () => {
    it('detects cursor from .cursor directory', () => {
      const tmp = makeTmpDir();
      try {
        fs.mkdirSync(path.join(tmp, '.cursor'), { recursive: true });
        assert.equal(hookAdapter.detectPlatform(tmp), 'cursor');
      } finally { cleanup(tmp); }
    });

    it('detects claude-code from .claude directory', () => {
      const tmp = makeTmpDir();
      try {
        fs.mkdirSync(path.join(tmp, '.claude'), { recursive: true });
        assert.equal(hookAdapter.detectPlatform(tmp), 'claude-code');
      } finally { cleanup(tmp); }
    });

    it('detects codex from .codex directory', () => {
      const tmp = makeTmpDir();
      try {
        fs.mkdirSync(path.join(tmp, '.codex'), { recursive: true });
        assert.equal(hookAdapter.detectPlatform(tmp), 'codex');
      } finally { cleanup(tmp); }
    });

    it('returns null for unknown platform when no fallback dirs exist', () => {
      const tmp = makeTmpDir();
      try {
        // detectPlatform checks cwd first, then homedir fallback.
        // On machines with ~/.cursor, it will find cursor via fallback.
        // This test only asserts that the cwd itself yields nothing.
        const result = hookAdapter.detectPlatform(tmp);
        // If homedir has a platform dir, the function returns that.
        // We just verify the function doesn't crash and returns a valid result.
        assert.ok(result === null || typeof result === 'string');
      } finally { cleanup(tmp); }
    });
  });

  describe('deepMerge', () => {
    it('merges nested objects', () => {
      const a = { x: { a: 1 }, y: 2 };
      const b = { x: { b: 3 }, z: 4 };
      const result = hookAdapter.deepMerge(a, b);
      assert.deepEqual(result, { x: { a: 1, b: 3 }, y: 2, z: 4 });
    });

    it('overwrites arrays', () => {
      const a = { arr: [1, 2] };
      const b = { arr: [3, 4, 5] };
      const result = hookAdapter.deepMerge(a, b);
      assert.deepEqual(result.arr, [3, 4, 5]);
    });
  });

  describe('mergeJsonFile', () => {
    it('creates file if not exists', () => {
      const tmp = makeTmpDir();
      try {
        const filePath = path.join(tmp, 'test.json');
        hookAdapter.mergeJsonFile(filePath, { hooks: { a: 1 } });
        const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
        assert.equal(data.hooks.a, 1);
        assert.equal(data._evolver_managed, true);
      } finally { cleanup(tmp); }
    });

    it('merges into existing file', () => {
      const tmp = makeTmpDir();
      try {
        const filePath = path.join(tmp, 'test.json');
        fs.writeFileSync(filePath, JSON.stringify({ existing: true, hooks: { old: 1 } }));
        hookAdapter.mergeJsonFile(filePath, { hooks: { new: 2 } });
        const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
        assert.equal(data.existing, true);
        assert.equal(data.hooks.old, 1);
        assert.equal(data.hooks.new, 2);
        assert.equal(data._evolver_managed, true);
      } finally { cleanup(tmp); }
    });
  });

  describe('appendSectionToFile', () => {
    it('appends section to new file', () => {
      const tmp = makeTmpDir();
      try {
        const filePath = path.join(tmp, 'README.md');
        const result = hookAdapter.appendSectionToFile(filePath, '<!-- marker -->', '<!-- marker -->\nHello');
        assert.equal(result, true);
        const content = fs.readFileSync(filePath, 'utf8');
        assert.ok(content.includes('<!-- marker -->'));
        assert.ok(content.includes('Hello'));
      } finally { cleanup(tmp); }
    });

    it('does not duplicate if marker exists', () => {
      const tmp = makeTmpDir();
      try {
        const filePath = path.join(tmp, 'README.md');
        fs.writeFileSync(filePath, '<!-- marker -->\nExisting');
        const result = hookAdapter.appendSectionToFile(filePath, '<!-- marker -->', '<!-- marker -->\nDuplicate');
        assert.equal(result, false);
      } finally { cleanup(tmp); }
    });
  });

  describe('copyHookScripts', () => {
    it('copies scripts to destination', () => {
      const tmp = makeTmpDir();
      try {
        const destDir = path.join(tmp, 'hooks');
        const evolverRoot = path.resolve(__dirname, '..');
        const copied = hookAdapter.copyHookScripts(destDir, path.join(evolverRoot, 'src', 'adapters'));
        assert.equal(copied.length, 3);
        for (const f of copied) {
          assert.ok(fs.existsSync(f));
        }
      } finally { cleanup(tmp); }
    });
  });

  describe('removeHookScripts', () => {
    it('removes evolver scripts', () => {
      const tmp = makeTmpDir();
      try {
        const hooksDir = path.join(tmp, 'hooks');
        fs.mkdirSync(hooksDir, { recursive: true });
        fs.writeFileSync(path.join(hooksDir, 'evolver-session-start.js'), '');
        fs.writeFileSync(path.join(hooksDir, 'evolver-signal-detect.js'), '');
        fs.writeFileSync(path.join(hooksDir, 'evolver-session-end.js'), '');
        fs.writeFileSync(path.join(hooksDir, 'user-custom.js'), '');
        const removed = hookAdapter.removeHookScripts(hooksDir);
        assert.equal(removed, 3);
        assert.ok(fs.existsSync(path.join(hooksDir, 'user-custom.js')));
      } finally { cleanup(tmp); }
    });
  });
});

// -- Cursor adapter --

describe('cursor adapter', () => {
  it('installs hooks correctly', () => {
    const tmp = makeTmpDir();
    try {
      fs.mkdirSync(path.join(tmp, '.cursor'), { recursive: true });
      const evolverRoot = path.resolve(__dirname, '..');
      const result = cursorAdapter.install({ configRoot: tmp, evolverRoot, force: true });
      assert.equal(result.ok, true);
      assert.equal(result.platform, 'cursor');
      const hooks = JSON.parse(fs.readFileSync(path.join(tmp, '.cursor', 'hooks.json'), 'utf8'));
      assert.ok(hooks.hooks.sessionStart);
      assert.ok(hooks.hooks.afterFileEdit);
      assert.ok(hooks.hooks.stop);
      assert.equal(hooks._evolver_managed, true);
      assert.ok(fs.existsSync(path.join(tmp, '.cursor', 'hooks', 'evolver-session-start.js')));
    } finally { cleanup(tmp); }
  });

  it('uninstalls hooks correctly', () => {
    const tmp = makeTmpDir();
    try {
      fs.mkdirSync(path.join(tmp, '.cursor'), { recursive: true });
      const evolverRoot = path.resolve(__dirname, '..');
      cursorAdapter.install({ configRoot: tmp, evolverRoot, force: true });
      const result = cursorAdapter.uninstall({ configRoot: tmp, evolverRoot });
      assert.equal(result.ok, true);
      assert.equal(result.removed, true);
      assert.ok(!fs.existsSync(path.join(tmp, '.cursor', 'hooks', 'evolver-session-start.js')));
    } finally { cleanup(tmp); }
  });

  it('buildHooksJson returns valid structure', () => {
    const hooks = cursorAdapter.buildHooksJson('/evolver', false);
    assert.equal(hooks.version, 1);
    assert.ok(hooks.hooks.sessionStart[0].command.includes('evolver-session-start'));
    assert.ok(hooks.hooks.afterFileEdit[0].command.includes('evolver-signal-detect'));
    assert.ok(hooks.hooks.stop[0].command.includes('evolver-session-end'));
  });

  it('buildHooksJson user-level uses ./hooks/ prefix', () => {
    const hooks = cursorAdapter.buildHooksJson('/evolver', true);
    assert.ok(hooks.hooks.sessionStart[0].command.startsWith('node ./hooks/'));
  });
});

// -- Claude Code adapter --

describe('claudeCode adapter', () => {
  it('installs hooks and CLAUDE.md', () => {
    const tmp = makeTmpDir();
    try {
      fs.mkdirSync(path.join(tmp, '.claude'), { recursive: true });
      const evolverRoot = path.resolve(__dirname, '..');
      const result = claudeAdapter.install({ configRoot: tmp, evolverRoot, force: true });
      assert.equal(result.ok, true);
      assert.equal(result.platform, 'claude-code');
      const settings = JSON.parse(fs.readFileSync(path.join(tmp, '.claude', 'settings.json'), 'utf8'));
      assert.ok(settings.hooks.SessionStart);
      assert.ok(settings.hooks.PostToolUse);
      assert.ok(settings.hooks.Stop);
      assert.ok(fs.existsSync(path.join(tmp, 'CLAUDE.md')));
      const claudeMd = fs.readFileSync(path.join(tmp, 'CLAUDE.md'), 'utf8');
      assert.ok(claudeMd.includes('Evolution Memory'));
    } finally { cleanup(tmp); }
  });

  it('uninstalls hooks and CLAUDE.md section', () => {
    const tmp = makeTmpDir();
    try {
      fs.mkdirSync(path.join(tmp, '.claude'), { recursive: true });
      const evolverRoot = path.resolve(__dirname, '..');
      claudeAdapter.install({ configRoot: tmp, evolverRoot, force: true });
      const result = claudeAdapter.uninstall({ configRoot: tmp });
      assert.equal(result.ok, true);
      assert.equal(result.removed, true);
      const claudeMd = fs.readFileSync(path.join(tmp, 'CLAUDE.md'), 'utf8');
      assert.ok(!claudeMd.includes('evolver-evolution-memory'));
    } finally { cleanup(tmp); }
  });

  it('buildClaudeHooks produces Claude Code HookMatcher structure', () => {
    const hooks = claudeAdapter.buildClaudeHooks('/evolver');
    for (const event of ['SessionStart', 'PostToolUse', 'Stop']) {
      const matchers = hooks.hooks[event];
      assert.ok(Array.isArray(matchers), `${event} must be an array`);
      assert.ok(matchers.length > 0, `${event} must have matchers`);
      for (const matcher of matchers) {
        assert.ok(Array.isArray(matcher.hooks), `${event} matcher must have .hooks array`);
        for (const cmd of matcher.hooks) {
          assert.equal(cmd.type, 'command');
          assert.equal(typeof cmd.command, 'string');
          assert.ok(cmd.command.length > 0);
        }
      }
    }
    assert.equal(hooks.hooks.PostToolUse[0].matcher, 'Write');
  });
});

// -- Codex adapter --

describe('codex adapter', () => {
  it('installs hooks, config.toml, and AGENTS.md', () => {
    const tmp = makeTmpDir();
    try {
      fs.mkdirSync(path.join(tmp, '.codex'), { recursive: true });
      const evolverRoot = path.resolve(__dirname, '..');
      const result = codexAdapter.install({ configRoot: tmp, evolverRoot, force: true });
      assert.equal(result.ok, true);
      assert.equal(result.platform, 'codex');
      const hooks = JSON.parse(fs.readFileSync(path.join(tmp, '.codex', 'hooks.json'), 'utf8'));
      assert.ok(hooks.hooks.SessionStart);
      assert.ok(hooks.hooks.Stop);
      const toml = fs.readFileSync(path.join(tmp, '.codex', 'config.toml'), 'utf8');
      assert.ok(toml.includes('codex_hooks = true'));
      assert.ok(fs.existsSync(path.join(tmp, 'AGENTS.md')));
    } finally { cleanup(tmp); }
  });

  it('ensureConfigToml adds feature flag', () => {
    const tmp = makeTmpDir();
    try {
      const codexDir = path.join(tmp, '.codex');
      fs.mkdirSync(codexDir, { recursive: true });
      const changed = codexAdapter.ensureConfigToml(codexDir);
      assert.equal(changed, true);
      const toml = fs.readFileSync(path.join(codexDir, 'config.toml'), 'utf8');
      assert.ok(toml.includes('[features]'));
      assert.ok(toml.includes('codex_hooks = true'));
      const noChange = codexAdapter.ensureConfigToml(codexDir);
      assert.equal(noChange, false);
    } finally { cleanup(tmp); }
  });

  it('uninstalls hooks and AGENTS.md section', () => {
    const tmp = makeTmpDir();
    try {
      fs.mkdirSync(path.join(tmp, '.codex'), { recursive: true });
      const evolverRoot = path.resolve(__dirname, '..');
      codexAdapter.install({ configRoot: tmp, evolverRoot, force: true });
      const result = codexAdapter.uninstall({ configRoot: tmp });
      assert.equal(result.ok, true);
      assert.equal(result.removed, true);
      const agentsMd = fs.readFileSync(path.join(tmp, 'AGENTS.md'), 'utf8');
      assert.ok(!agentsMd.includes('evolver-evolution-memory'));
    } finally { cleanup(tmp); }
  });
});