@draig/lexis-two 1.0.0

package/tests/hooks-windows.test.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// Regression test for issue #19: on Windows the lifecycle hooks run via
+// PowerShell, which does NOT expand cmd.exe-style %VAR% — it needs $env:VAR.
+// The hook also has to point at a script that actually ships in hooks/.
+// This guards both failure modes: the original %CLAUDE_PLUGIN_ROOT% bug, and
+// the "switch to a .ps1 that doesn't exist" mistake.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+
+const root = path.join(__dirname, '..');
+const HOOKS_JSON = 'hooks/hooks.json';
+// cmd.exe variable syntax (%FOO%); PowerShell leaves it literal, breaking the path.
+const CMD_VAR_SYNTAX = /%[A-Za-z_][A-Za-z0-9_]*%/;
+// Pull the hooks/<script> a command launches, so we can check it exists.
+const HOOK_SCRIPT = /hooks[\\/]([\w.-]+\.(?:js|mjs|cjs|ps1|sh))/;
+
+// Read inside each case so a missing/malformed file fails as a clean assertion,
+// not a load-time crash.
+function commandHooks() {
+  const config = JSON.parse(fs.readFileSync(path.join(root, HOOKS_JSON), 'utf8'));
+  return Object.values(config.hooks)
+    .flat()
+    .flatMap((entry) => entry.hooks);
+}
+
+test('every commandWindows uses PowerShell $env: syntax, not cmd.exe %VAR%', () => {
+  const windowsCommands = commandHooks()
+    .map((h) => h.commandWindows)
+    .filter(Boolean);
+  assert.ok(windowsCommands.length > 0, 'expected at least one commandWindows entry');
+  for (const cmd of windowsCommands) {
+    assert.doesNotMatch(cmd, CMD_VAR_SYNTAX, `commandWindows uses cmd.exe %VAR% (breaks under PowerShell): ${cmd}`);
+  }
+});
+
+test('every hook command points at a script that ships in hooks/', () => {
+  for (const hook of commandHooks()) {
+    for (const cmd of [hook.command, hook.commandWindows].filter(Boolean)) {
+      const match = cmd.match(HOOK_SCRIPT);
+      assert.ok(match, `cannot find a hooks/ script in command: ${cmd}`);
+      const script = path.join(root, 'hooks', match[1]);
+      assert.ok(fs.existsSync(script), `command references a missing hook script: ${match[1]}`);
+    }
+  }
+});

package/tests/hooks.test.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const root = path.join(__dirname, '..');
+
+function run(script, env, input = '') {
+  return spawnSync(process.execPath, [path.join(root, 'hooks', script)], {
+    env: { ...process.env, ...env },
+    input,
+    encoding: 'utf8',
+  });
+}
+
+test('hooks integration tests', async (t) => {
+  let originalEnv;
+  let temp;
+  let home;
+  let pluginData;
+  let codexEnv;
+  let codexState;
+
+  t.beforeEach(() => {
+    // Save original env and clean it
+    originalEnv = { ...process.env };
+    delete process.env.CLAUDE_CONFIG_DIR;
+    delete process.env.LEXIS_TWO_DEFAULT_MODE;
+
+    temp = fs.mkdtempSync(path.join(os.tmpdir(), 'lexis-two-hooks-'));
+    home = path.join(temp, 'home');
+    pluginData = path.join(temp, 'plugin-data');
+    fs.mkdirSync(home, { recursive: true });
+
+    codexEnv = {
+      HOME: home,
+      USERPROFILE: home,
+      PLUGIN_DATA: pluginData,
+      LEXIS_TWO_DEFAULT_MODE: 'ultra',
+    };
+    codexState = path.join(pluginData, '.lexis-two-active');
+  });
+
+  t.afterEach(() => {
+    // Restore original env and clean temp folder
+    process.env = originalEnv;
+    try {
+      fs.rmSync(temp, { recursive: true, force: true });
+    } catch (e) {}
+  });
+
+  await t.test('lexis-two-activate.js activates ultra mode for Codex', () => {
+    const result = run('lexis-two-activate.js', codexEnv);
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(fs.readFileSync(codexState, 'utf8'), 'ultra');
+    const output = JSON.parse(result.stdout);
+    assert.equal(output.systemMessage, 'LEXIS-TWO:ULTRA');
+    assert.match(
+      output.hookSpecificOutput.additionalContext,
+      /LEXIS-TWO MODE ACTIVE — level: ultra/,
+    );
+  });
+
+  await t.test('lexis-two-mode-tracker.js switches mode to lite', () => {
+    // First activate
+    run('lexis-two-activate.js', codexEnv);
+
+    const result = run(
+      'lexis-two-mode-tracker.js',
+      codexEnv,
+      JSON.stringify({ prompt: '@lexis-two lite' }),
+    );
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(fs.readFileSync(codexState, 'utf8'), 'lite');
+    const output = JSON.parse(result.stdout);
+    assert.equal(output.systemMessage, 'LEXIS-TWO:LITE');
+  });
+
+  await t.test('lexis-two-mode-tracker.js deactivates mode with normal prompt', () => {
+    // First activate
+    run('lexis-two-activate.js', codexEnv);
+
+    const result = run(
+      'lexis-two-mode-tracker.js',
+      codexEnv,
+      JSON.stringify({ prompt: 'normal mode' }),
+    );
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(fs.existsSync(codexState), false);
+    const output = JSON.parse(result.stdout);
+    assert.equal(output.systemMessage, 'LEXIS-TWO:OFF');
+  });
+
+  await t.test('lexis-two-activate.js activates full mode for Claude', () => {
+    const claudeEnv = {
+      HOME: home,
+      USERPROFILE: home,
+      LEXIS_TWO_DEFAULT_MODE: 'full',
+    };
+
+    const result = run('lexis-two-activate.js', claudeEnv);
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(
+      fs.readFileSync(path.join(home, '.claude', '.lexis-two-active'), 'utf8'),
+      'full',
+    );
+  });
+
+  await t.test('CLAUDE_CONFIG_DIR overrides ~/.claude for Claude flag file', () => {
+    const home2 = path.join(temp, 'home2');
+    fs.mkdirSync(home2, { recursive: true });
+    const customConfigDir = path.join(temp, 'custom-claude');
+
+    const result = run('lexis-two-activate.js', {
+      HOME: home2,
+      USERPROFILE: home2,
+      CLAUDE_CONFIG_DIR: customConfigDir,
+      LEXIS_TWO_DEFAULT_MODE: 'lite',
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(
+      fs.readFileSync(path.join(customConfigDir, '.lexis-two-active'), 'utf8'),
+      'lite',
+    );
+    assert.equal(
+      fs.existsSync(path.join(home2, '.claude', '.lexis-two-active')),
+      false,
+      'flag must not land in ~/.claude when CLAUDE_CONFIG_DIR is set',
+    );
+  });
+
+  await t.test('copilot hooks isolate state from Codex', () => {
+    const copilotData = path.join(temp, 'copilot-data');
+    const codexData = path.join(temp, 'codex-data-shadow');
+
+    let result = run('lexis-two-activate.js', {
+      HOME: home,
+      USERPROFILE: home,
+      COPILOT_PLUGIN_DATA: copilotData,
+      PLUGIN_DATA: codexData,
+      LEXIS_TWO_DEFAULT_MODE: 'full',
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(fs.readFileSync(path.join(copilotData, '.lexis-two-active'), 'utf8'), 'full');
+    assert.equal(
+      fs.existsSync(path.join(codexData, '.lexis-two-active')),
+      false,
+      'copilot hooks must not write mode state to codex PLUGIN_DATA',
+    );
+    let output = JSON.parse(result.stdout);
+    assert.match(output.additionalContext, /LEXIS-TWO MODE ACTIVE — level: full/);
+
+    result = run(
+      'lexis-two-mode-tracker.js',
+      {
+        HOME: home,
+        USERPROFILE: home,
+        COPILOT_PLUGIN_DATA: copilotData,
+        PLUGIN_DATA: codexData,
+      },
+      JSON.stringify({ prompt: '/lexis-two ultra' }),
+    );
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(fs.readFileSync(path.join(copilotData, '.lexis-two-active'), 'utf8'), 'ultra');
+    assert.equal(
+      fs.existsSync(path.join(codexData, '.lexis-two-active')),
+      false,
+      'copilot mode tracker must keep codex PLUGIN_DATA untouched',
+    );
+    output = JSON.parse(result.stdout);
+    assert.deepEqual(output, {});
+  });
+});

package/tests/opencode-plugin.test.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// Smoke test for the OpenCode adapter: the plugin's hooks behave against the
+// real (structural) OpenCode hook shapes. No live OpenCode needed.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { pathToFileURL } = require('url');
+
+// Point the plugin's mode-flag at a temp config home BEFORE it loads — the
+// plugin resolves its state path once at load (as it does under a real OpenCode
+// process, where XDG_CONFIG_HOME is already set). The dynamic import below runs
+// after this assignment, so the ordering holds.
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'lexis-two-opencode-'));
+process.env.XDG_CONFIG_HOME = tmp;
+delete process.env.LEXIS_TWO_DEFAULT_MODE;
+const statePath = path.join(tmp, 'opencode', '.lexis-two-active');
+
+let loadPlugin;
+test.before(async () => {
+  const url = pathToFileURL(path.join(__dirname, '..', '.opencode', 'plugins', 'lexis-two.mjs'));
+  loadPlugin = (await import(url)).default;
+});
+
+function transform(hooks) {
+  const output = { system: [] };
+  return hooks['experimental.chat.system.transform']({ model: {} }, output).then(() => output.system);
+}
+
+test('system.transform injects the ruleset at the default mode (full)', async () => {
+  try { fs.unlinkSync(statePath); } catch (e) {}
+  const hooks = await loadPlugin({});
+  const system = await transform(hooks);
+  assert.equal(system.length, 1);
+  assert.match(system[0], /LEXIS-TWO MODE ACTIVE — level: full/);
+  assert.match(system[0], /lazy senior developer/);
+});
+
+test('command.execute.before persists /lexis-two ultra, transform follows it', async () => {
+  const hooks = await loadPlugin({});
+  await hooks['command.execute.before']({ command: 'lexis-two', arguments: 'ultra', sessionID: 's' });
+  assert.equal(fs.readFileSync(statePath, 'utf8'), 'ultra');
+  const system = await transform(hooks);
+  assert.match(system[0], /LEXIS-TWO MODE ACTIVE — level: ultra/);
+});
+
+test('/lexis-two off persists off and transform injects nothing', async () => {
+  const hooks = await loadPlugin({});
+  await hooks['command.execute.before']({ command: 'lexis-two', arguments: 'off', sessionID: 's' });
+  assert.equal(fs.readFileSync(statePath, 'utf8'), 'off');
+  const system = await transform(hooks);
+  assert.deepEqual(system, []);
+});
+
+test('unrelated commands do not touch the flag', async () => {
+  try { fs.unlinkSync(statePath); } catch (e) {}
+  const hooks = await loadPlugin({});
+  await hooks['command.execute.before']({ command: 'commit', arguments: 'x', sessionID: 's' });
+  assert.equal(fs.existsSync(statePath), false);
+});
+
+test.after(() => fs.rmSync(tmp, { recursive: true, force: true }));