@pcircle/memesh 2.10.1 → 2.11.0

package/scripts/hooks/__tests__/hook-test-harness.js

@@ -1,218 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Hook Test Harness — Simulates Claude Code hook execution.
- *
- * Pipes mock stdin JSON to a hook script and validates the output.
- * Does NOT require Claude Code runtime.
- *
- * Usage:
- *   node hook-test-harness.js <hook-script> <mock-stdin-json>
- *   node hook-test-harness.js ../pre-tool-use.js '{"tool_name":"Bash","tool_input":{"command":"git commit -m test"}}'
- *
- * Or programmatically:
- *   import { runHook, assertJSON, assertContains } from './hook-test-harness.js';
- */
-
-import { execFile } from 'child_process';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// ============================================================================
-// Core Test Functions
-// ============================================================================
-
-/**
- * Run a hook script with mock stdin and capture output.
- *
- * @param {string} hookPath - Path to hook script (relative to hooks/ dir or absolute)
- * @param {Object|string} stdinData - JSON data to pipe as stdin
- * @param {Object} options - Options
- * @param {number} options.timeout - Timeout in ms (default: 10000)
- * @param {Object} options.env - Additional environment variables
- * @returns {Promise<{ stdout: string, stderr: string, exitCode: number, parsed: Object|null }>}
- */
-export function runHook(hookPath, stdinData, options = {}) {
-  const { timeout = 10000, env = {} } = options;
-
-  // Resolve hook path relative to hooks directory
-  const resolvedPath = path.isAbsolute(hookPath)
-    ? hookPath
-    : path.resolve(__dirname, '..', hookPath);
-
-  const stdinStr = typeof stdinData === 'string'
-    ? stdinData
-    : JSON.stringify(stdinData);
-
-  return new Promise((resolve) => {
-    const child = execFile('node', [resolvedPath], {
-      encoding: 'utf-8',
-      timeout,
-      env: { ...process.env, ...env },
-    }, (error, stdout, stderr) => {
-      let parsed = null;
-      try {
-        if (stdout.trim()) {
-          parsed = JSON.parse(stdout.trim());
-        }
-      } catch {
-        // Not JSON output — that's fine for some hooks
-      }
-
-      resolve({
-        stdout: stdout || '',
-        stderr: stderr || '',
-        exitCode: error ? (error.code || 1) : 0,
-        parsed,
-      });
-    });
-
-    // Pipe stdin
-    if (child.stdin) {
-      child.stdin.write(stdinStr);
-      child.stdin.end();
-    }
-  });
-}
-
-// ============================================================================
-// Assertion Helpers
-// ============================================================================
-
-/**
- * Assert that the hook output is valid JSON with expected structure.
- * @param {Object} result - Result from runHook()
- * @param {string} hookEventName - Expected hookEventName
- * @returns {boolean}
- */
-export function assertHookResponse(result, hookEventName) {
-  if (!result.parsed) {
-    console.error(`  FAIL: No JSON output`);
-    return false;
-  }
-
-  const output = result.parsed.hookSpecificOutput;
-  if (!output) {
-    console.error(`  FAIL: Missing hookSpecificOutput`);
-    return false;
-  }
-
-  if (output.hookEventName !== hookEventName) {
-    console.error(`  FAIL: hookEventName is "${output.hookEventName}", expected "${hookEventName}"`);
-    return false;
-  }
-
-  return true;
-}
-
-/**
- * Assert that stdout contains a substring.
- * @param {Object} result - Result from runHook()
- * @param {string} substring - Expected substring
- * @returns {boolean}
- */
-export function assertContains(result, substring) {
-  const fullOutput = result.stdout + result.stderr;
-  if (!fullOutput.includes(substring)) {
-    console.error(`  FAIL: Output does not contain "${substring}"`);
-    return false;
-  }
-  return true;
-}
-
-/**
- * Assert hook exited silently (no stdout, exit 0).
- * @param {Object} result - Result from runHook()
- * @returns {boolean}
- */
-export function assertSilent(result) {
-  if (result.stdout.trim() !== '') {
-    console.error(`  FAIL: Expected silent exit, got stdout: ${result.stdout.substring(0, 100)}`);
-    return false;
-  }
-  return true;
-}
-
-// ============================================================================
-// Test Runner
-// ============================================================================
-
-/**
- * Simple test runner for hook tests.
- * @param {string} suiteName - Test suite name
- * @param {Array<{name: string, fn: Function}>} tests - Test cases
- */
-export async function runTests(suiteName, tests) {
-  console.log(`\n  ${suiteName}`);
-  console.log('  ' + '─'.repeat(50));
-
-  let passed = 0;
-  let failed = 0;
-
-  for (const test of tests) {
-    try {
-      const result = await test.fn();
-      if (result !== false) {
-        console.log(`  ✅ ${test.name}`);
-        passed++;
-      } else {
-        console.log(`  ❌ ${test.name}`);
-        failed++;
-      }
-    } catch (error) {
-      console.log(`  ❌ ${test.name}`);
-      console.error(`     Error: ${error.message}`);
-      failed++;
-    }
-  }
-
-  console.log('  ' + '─'.repeat(50));
-  console.log(`  Results: ${passed} passed, ${failed} failed\n`);
-
-  return { passed, failed };
-}
-
-// ============================================================================
-// CLI Mode
-// ============================================================================
-
-async function main() {
-  const args = process.argv.slice(2);
-
-  if (args.length < 2) {
-    console.log('Usage: node hook-test-harness.js <hook-script> <mock-stdin-json>');
-    console.log('');
-    console.log('Examples:');
-    console.log('  node hook-test-harness.js pre-tool-use.js \'{"tool_name":"Bash","tool_input":{"command":"git commit -m test"}}\'');
-    console.log('  node hook-test-harness.js post-tool-use.js \'{"tool_name":"Read","tool_input":{"file_path":"/tmp/test.js"}}\'');
-    process.exit(0);
-  }
-
-  const [hookScript, stdinJSON] = args;
-
-  console.log(`\nRunning: ${hookScript}`);
-  console.log(`Stdin: ${stdinJSON.substring(0, 100)}...`);
-  console.log('');
-
-  const result = await runHook(hookScript, stdinJSON);
-
-  console.log(`Exit code: ${result.exitCode}`);
-  if (result.stdout.trim()) {
-    console.log(`Stdout: ${result.stdout.trim()}`);
-  }
-  if (result.stderr.trim()) {
-    console.log(`Stderr: ${result.stderr.trim()}`);
-  }
-  if (result.parsed) {
-    console.log(`Parsed JSON:`);
-    console.log(JSON.stringify(result.parsed, null, 2));
-  }
-}
-
-// Run CLI mode if invoked directly
-if (process.argv[1] && process.argv[1].includes('hook-test-harness')) {
-  main().catch(console.error);
-}

package/scripts/hooks/__tests__/hooks.test.js

@@ -1,267 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Hook Tests — Validates hook behavior without Claude Code runtime.
- *
- * Run: node scripts/hooks/__tests__/hooks.test.js
- */
-
-import { runHook, assertHookResponse, assertSilent, runTests } from './hook-test-harness.js';
-
-// ============================================================================
-// PreToolUse Tests
-// ============================================================================
-
-const preToolUseTests = [
-  {
-    name: 'Git commit without review triggers reminder or silent exit',
-    fn: async () => {
-      const result = await runHook('pre-tool-use.js', {
-        tool_name: 'Bash',
-        tool_input: { command: 'git commit -m "test commit"' },
-      });
-      // Should produce JSON output with review reminder
-      // OR exit silently if codeReviewDone=true from prior test
-      if (result.parsed) {
-        return assertHookResponse(result, 'PreToolUse');
-      }
-      // Silent exit is acceptable (review already done or no session file)
-      return assertSilent(result);
-    },
-  },
-  {
-    name: 'Non-git-commit Bash exits silently',
-    fn: async () => {
-      const result = await runHook('pre-tool-use.js', {
-        tool_name: 'Bash',
-        tool_input: { command: 'ls -la' },
-      });
-      return assertSilent(result);
-    },
-  },
-  {
-    name: 'Non-Bash tool exits silently',
-    fn: async () => {
-      const result = await runHook('pre-tool-use.js', {
-        tool_name: 'Read',
-        tool_input: { file_path: '/tmp/test.js' },
-      });
-      return assertSilent(result);
-    },
-  },
-  {
-    name: 'Git amend exits silently',
-    fn: async () => {
-      const result = await runHook('pre-tool-use.js', {
-        tool_name: 'Bash',
-        tool_input: { command: 'git commit --amend -m "fix"' },
-      });
-      return assertSilent(result);
-    },
-  },
-  {
-    name: 'Empty stdin exits without error',
-    fn: async () => {
-      const result = await runHook('pre-tool-use.js', '');
-      return result.exitCode === 0;
-    },
-  },
-];
-
-// ============================================================================
-// PreToolUse — Smart Router Tests (1B)
-// ============================================================================
-
-const smartRouterTests = [
-  {
-    name: 'Task(Explore) gets model routing or silent exit',
-    fn: async () => {
-      const result = await runHook('pre-tool-use.js', {
-        tool_name: 'Task',
-        tool_input: { subagent_type: 'Explore', prompt: 'find auth code' },
-      });
-      // Either: hook produces routing output with haiku, or exits silently (no config)
-      if (!result.parsed) {
-        return assertSilent(result); // No output = no config, valid
-      }
-      const output = result.parsed?.hookSpecificOutput;
-      if (!output) return false; // Parsed but no hookSpecificOutput = malformed
-      // If routing was applied, model should be haiku
-      if (output.updatedInput?.model) {
-        return output.updatedInput.model === 'haiku';
-      }
-      // Output present but no model routing = other handler fired, OK
-      return true;
-    },
-  },
-  {
-    name: 'Task with explicit model preserves user choice',
-    fn: async () => {
-      const result = await runHook('pre-tool-use.js', {
-        tool_name: 'Task',
-        tool_input: { subagent_type: 'Explore', model: 'opus', prompt: 'deep analysis' },
-      });
-      // Should NOT override user's explicit model
-      if (result.parsed?.hookSpecificOutput?.updatedInput?.model) {
-        // Any model override when user specified 'opus' is wrong
-        return false;
-      }
-      // No model override = correct behavior
-      return true;
-    },
-  },
-  {
-    name: 'Task(Plan) gets planning template injected',
-    fn: async () => {
-      const result = await runHook('pre-tool-use.js', {
-        tool_name: 'Task',
-        tool_input: { subagent_type: 'Plan', prompt: 'plan the auth refactor' },
-      });
-      if (!result.parsed) {
-        // No output = template file not found. Acceptable but log it.
-        return assertSilent(result);
-      }
-      const output = result.parsed?.hookSpecificOutput;
-      if (!output) return false; // Parsed but no hookSpecificOutput = malformed
-      // Prompt should contain original + template content
-      if (output.updatedInput?.prompt) {
-        const prompt = output.updatedInput.prompt;
-        // Must contain original prompt AND some template content
-        return prompt.includes('plan the auth refactor') &&
-               (prompt.includes('Required Plan Sections') || prompt.includes('---'));
-      }
-      // No prompt modification = handler didn't fire, unexpected
-      return false;
-    },
-  },
-  {
-    name: 'EnterPlanMode gets context with template reference',
-    fn: async () => {
-      const result = await runHook('pre-tool-use.js', {
-        tool_name: 'EnterPlanMode',
-        tool_input: {},
-      });
-      if (!result.parsed) {
-        // No output = template file not found. Acceptable.
-        return assertSilent(result);
-      }
-      const output = result.parsed?.hookSpecificOutput;
-      if (!output) return false; // Parsed but no hookSpecificOutput = malformed
-      if (output.additionalContext) {
-        return output.additionalContext.includes('PLANNING MODE');
-      }
-      // hookSpecificOutput without additionalContext = wrong handler response
-      return false;
-    },
-  },
-  {
-    name: 'Non-Task tool is not affected by routing',
-    fn: async () => {
-      const result = await runHook('pre-tool-use.js', {
-        tool_name: 'Grep',
-        tool_input: { pattern: 'test', path: '/tmp' },
-      });
-      return assertSilent(result);
-    },
-  },
-];
-
-// ============================================================================
-// PostToolUse Tests
-// ============================================================================
-
-const postToolUseTests = [
-  {
-    name: 'Read tool exits silently',
-    fn: async () => {
-      const result = await runHook('post-tool-use.js', {
-        tool_name: 'Read',
-        tool_input: { file_path: '/tmp/test.js' },
-        success: true,
-      });
-      return assertSilent(result);
-    },
-  },
-  {
-    name: 'Bash tool exits silently',
-    fn: async () => {
-      const result = await runHook('post-tool-use.js', {
-        tool_name: 'Bash',
-        tool_input: { command: 'echo hello' },
-        success: true,
-      });
-      return assertSilent(result);
-    },
-  },
-  {
-    name: 'Empty stdin exits without error',
-    fn: async () => {
-      const result = await runHook('post-tool-use.js', '');
-      return result.exitCode === 0;
-    },
-  },
-];
-
-// ============================================================================
-// PostCommit Tests
-// ============================================================================
-
-const postCommitTests = [
-  {
-    name: 'Non-git-commit exits silently',
-    fn: async () => {
-      const result = await runHook('post-commit.js', {
-        tool_name: 'Read',
-        tool_input: { file_path: '/tmp/test.js' },
-        success: true,
-      });
-      return assertSilent(result);
-    },
-  },
-  {
-    name: 'Failed command exits silently',
-    fn: async () => {
-      const result = await runHook('post-commit.js', {
-        tool_name: 'Bash',
-        tool_input: { command: 'git commit -m "test"' },
-        success: false,
-      });
-      return assertSilent(result);
-    },
-  },
-];
-
-// ============================================================================
-// Run All Tests
-// ============================================================================
-
-async function main() {
-  console.log('\n🧪 Hook Test Suite\n');
-
-  let totalPassed = 0;
-  let totalFailed = 0;
-
-  const suites = [
-    { name: 'PreToolUse Hook (Code Review)', tests: preToolUseTests },
-    { name: 'PreToolUse Hook (Smart Router)', tests: smartRouterTests },
-    { name: 'PostToolUse Hook', tests: postToolUseTests },
-    { name: 'PostCommit Hook', tests: postCommitTests },
-  ];
-
-  for (const suite of suites) {
-    const { passed, failed } = await runTests(suite.name, suite.tests);
-    totalPassed += passed;
-    totalFailed += failed;
-  }
-
-  console.log('═'.repeat(55));
-  console.log(`  Total: ${totalPassed} passed, ${totalFailed} failed`);
-  console.log('═'.repeat(55));
-
-  process.exit(totalFailed > 0 ? 1 : 0);
-}
-
-main().catch(error => {
-  console.error('Test runner error:', error);
-  process.exit(1);
-});

package/scripts/hooks/__tests__/post-tool-use-recall.test.js

@@ -1,192 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  isTestCommand,
-  extractTestFailureContext,
-  buildTestFailureQuery,
-  buildErrorQuery,
-} from '../post-tool-use-recall-utils.js';
-
-describe('isTestCommand', () => {
-  it('detects "npm test"', () => {
-    expect(isTestCommand('npm test')).toBe(true);
-  });
-
-  it('detects "npm run test"', () => {
-    expect(isTestCommand('npm run test')).toBe(true);
-  });
-
-  it('detects "npx vitest"', () => {
-    expect(isTestCommand('npx vitest')).toBe(true);
-  });
-
-  it('detects "vitest run"', () => {
-    expect(isTestCommand('vitest run')).toBe(true);
-  });
-
-  it('detects "vitest" alone', () => {
-    expect(isTestCommand('vitest')).toBe(true);
-  });
-
-  it('detects "npx jest"', () => {
-    expect(isTestCommand('npx jest')).toBe(true);
-  });
-
-  it('detects "jest" alone', () => {
-    expect(isTestCommand('jest')).toBe(true);
-  });
-
-  it('detects "pytest"', () => {
-    expect(isTestCommand('pytest')).toBe(true);
-  });
-
-  it('detects "bun test"', () => {
-    expect(isTestCommand('bun test')).toBe(true);
-  });
-
-  it('detects "mocha"', () => {
-    expect(isTestCommand('mocha')).toBe(true);
-  });
-
-  it('rejects "ls -la"', () => {
-    expect(isTestCommand('ls -la')).toBe(false);
-  });
-
-  it('rejects "git commit"', () => {
-    expect(isTestCommand('git commit -m "test"')).toBe(false);
-  });
-
-  it('rejects "echo test"', () => {
-    expect(isTestCommand('echo test')).toBe(false);
-  });
-
-  it('rejects empty string', () => {
-    expect(isTestCommand('')).toBe(false);
-  });
-
-  it('rejects null/undefined', () => {
-    expect(isTestCommand(null)).toBe(false);
-    expect(isTestCommand(undefined)).toBe(false);
-  });
-
-  it('is case-insensitive', () => {
-    expect(isTestCommand('NPM TEST')).toBe(true);
-    expect(isTestCommand('Vitest Run')).toBe(true);
-  });
-});
-
-describe('extractTestFailureContext', () => {
-  it('returns null for null/undefined/empty input', () => {
-    expect(extractTestFailureContext(null)).toBeNull();
-    expect(extractTestFailureContext(undefined)).toBeNull();
-    expect(extractTestFailureContext('')).toBeNull();
-  });
-
-  it('returns null for passing test output', () => {
-    const output = `
- ✓ src/utils/helper.test.ts (3 tests) 12ms
- Test Files  1 passed (1)
- Tests  3 passed (3)
-`;
-    expect(extractTestFailureContext(output)).toBeNull();
-  });
-
-  it('extracts from vitest FAIL output', () => {
-    const output = `
- FAIL  src/mcp/handlers/HookToolHandler.test.ts
- ✕ should process tool use (5ms)
- Error: expect(received).toBe(expected)
-`;
-    const ctx = extractTestFailureContext(output);
-    expect(ctx).not.toBeNull();
-    expect(ctx.testName).toBe('src/mcp/handlers/HookToolHandler.test.ts');
-    expect(ctx.errorMessage).toMatch(/Error/);
-  });
-
-  it('extracts from jest-style FAIL output', () => {
-    const output = `
-FAIL src/auth/login.test.js
-  ● should validate credentials
-    expect(received).toBe(expected)
-`;
-    const ctx = extractTestFailureContext(output);
-    expect(ctx).not.toBeNull();
-    expect(ctx.testName).toBe('src/auth/login.test.js');
-  });
-
-  it('extracts error message from output with "failed"', () => {
-    const output = `
-Tests: 2 failed, 5 passed
-Error: Connection refused
-`;
-    const ctx = extractTestFailureContext(output);
-    expect(ctx).not.toBeNull();
-    expect(ctx.errorMessage).toMatch(/Error.*Connection refused/);
-  });
-
-  it('handles output with ✕ marker', () => {
-    const output = `
- ✕ my test case
-`;
-    const ctx = extractTestFailureContext(output);
-    expect(ctx).not.toBeNull();
-  });
-});
-
-describe('buildTestFailureQuery', () => {
-  it('combines short test name + error message', () => {
-    const result = buildTestFailureQuery('src/utils/helper.test.ts', 'Connection refused');
-    expect(result).toBe('helper Connection refused');
-  });
-
-  it('strips directory path and test/spec suffix', () => {
-    const result = buildTestFailureQuery('src/mcp/handlers/HookToolHandler.test.ts', 'error');
-    expect(result).toBe('HookToolHandler error');
-  });
-
-  it('strips spec suffix', () => {
-    const result = buildTestFailureQuery('auth.spec.js', 'fail');
-    expect(result).toBe('auth fail');
-  });
-
-  it('handles unknown test name', () => {
-    const result = buildTestFailureQuery('unknown test', 'some error');
-    expect(result).toBe('unknown test some error');
-  });
-
-  it('handles empty error message', () => {
-    const result = buildTestFailureQuery('src/foo.test.ts', '');
-    expect(result).toBe('foo');
-  });
-});
-
-describe('buildErrorQuery', () => {
-  it('combines error type + first line of message', () => {
-    const result = buildErrorQuery('TypeError', 'Cannot read property x of undefined');
-    expect(result).toBe('TypeError Cannot read property x of undefined');
-  });
-
-  it('uses only first line of multiline message', () => {
-    const result = buildErrorQuery('ReferenceError', 'x is not defined\n    at foo.js:10\n    at bar.js:20');
-    expect(result).toBe('ReferenceError x is not defined');
-  });
-
-  it('handles null/undefined error type', () => {
-    const result = buildErrorQuery(null, 'something broke');
-    expect(result).toBe('Error something broke');
-  });
-
-  it('handles undefined error type', () => {
-    const result = buildErrorQuery(undefined, 'something broke');
-    expect(result).toBe('Error something broke');
-  });
-
-  it('handles null/undefined error message', () => {
-    const result = buildErrorQuery('SyntaxError', null);
-    expect(result).toBe('SyntaxError');
-  });
-
-  it('handles empty inputs', () => {
-    const result = buildErrorQuery('', '');
-    expect(result).toBe('Error');
-  });
-});