@soleri/cli 9.4.0 → 9.5.0

package/src/__tests__/hooks-convert.test.ts

@@ -0,0 +1,342 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  generateHookScript,
+  generateManifest,
+  HOOK_EVENTS,
+  ACTION_LEVELS,
+} from '../hook-packs/converter/template.js';
+import type { HookConversionConfig } from '../hook-packs/converter/template.js';
+
+const tempDir = join(tmpdir(), `hooks-convert-test-${Date.now()}`);
+
+describe('hooks convert', () => {
+  beforeEach(() => {
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('generateManifest', () => {
+    it('should produce valid JSON with correct fields', () => {
+      const config: HookConversionConfig = {
+        name: 'brand-voice',
+        event: 'PreToolUse',
+        toolMatcher: 'Write|Edit',
+        action: 'remind',
+        message: 'Follow brand voice guidelines',
+      };
+
+      const manifest = generateManifest(config);
+
+      expect(manifest.name).toBe('brand-voice');
+      expect(manifest.version).toBe('1.0.0');
+      expect(manifest.description).toBe('Follow brand voice guidelines');
+      expect(manifest.hooks).toEqual([]);
+      expect(manifest.scripts).toHaveLength(1);
+      expect(manifest.scripts![0].name).toBe('brand-voice');
+      expect(manifest.scripts![0].file).toBe('brand-voice.sh');
+      expect(manifest.scripts![0].targetDir).toBe('hooks');
+      expect(manifest.lifecycleHooks).toHaveLength(1);
+      expect(manifest.lifecycleHooks![0].event).toBe('PreToolUse');
+      expect(manifest.lifecycleHooks![0].matcher).toBe('Write|Edit');
+      expect(manifest.actionLevel).toBe('remind');
+
+      // Verify it serializes to valid JSON
+      const json = JSON.stringify(manifest);
+      expect(() => JSON.parse(json)).not.toThrow();
+    });
+
+    it('should use message as description when no description provided', () => {
+      const config: HookConversionConfig = {
+        name: 'test-hook',
+        event: 'PreCompact',
+        action: 'warn',
+        message: 'Save session state',
+      };
+
+      const manifest = generateManifest(config);
+      expect(manifest.description).toBe('Save session state');
+    });
+
+    it('should use custom description when provided', () => {
+      const config: HookConversionConfig = {
+        name: 'test-hook',
+        event: 'PreCompact',
+        action: 'warn',
+        message: 'Save session state',
+        description: 'Custom description here',
+      };
+
+      const manifest = generateManifest(config);
+      expect(manifest.description).toBe('Custom description here');
+    });
+
+    it('should set empty matcher for non-tool events', () => {
+      const config: HookConversionConfig = {
+        name: 'compact-hook',
+        event: 'PreCompact',
+        action: 'remind',
+        message: 'Capture session',
+      };
+
+      const manifest = generateManifest(config);
+      expect(manifest.lifecycleHooks![0].matcher).toBe('');
+    });
+  });
+
+  describe('generateHookScript', () => {
+    it('should produce a valid shell script with shebang', () => {
+      const config: HookConversionConfig = {
+        name: 'test-hook',
+        event: 'PreToolUse',
+        toolMatcher: 'Write',
+        action: 'remind',
+        message: 'Check before writing',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).toMatch(/^#!\/bin\/sh/);
+      expect(script).toContain('set -eu');
+      expect(script).toContain('INPUT=$(cat)');
+    });
+
+    it('should include tool matcher case statement for PreToolUse', () => {
+      const config: HookConversionConfig = {
+        name: 'write-guard',
+        event: 'PreToolUse',
+        toolMatcher: 'Write|Edit',
+        action: 'warn',
+        message: 'Be careful with writes',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).toContain('TOOL_NAME=');
+      expect(script).toContain('case "$TOOL_NAME" in');
+      expect(script).toContain('Write|Edit');
+    });
+
+    it('should include file pattern matching when patterns provided', () => {
+      const config: HookConversionConfig = {
+        name: 'marketing-guard',
+        event: 'PreToolUse',
+        toolMatcher: 'Write',
+        filePatterns: ['**/marketing/**'],
+        action: 'block',
+        message: 'Marketing files require review',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).toContain('FILE_PATH=');
+      expect(script).toContain('MATCHED=false');
+      expect(script).toContain('grep -qE');
+    });
+
+    it('should output block JSON for action=block', () => {
+      const config: HookConversionConfig = {
+        name: 'blocker',
+        event: 'PreToolUse',
+        action: 'block',
+        message: 'Blocked operation',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).toContain('continue: false');
+      expect(script).toContain('BLOCKED:');
+    });
+
+    it('should output warn JSON for action=warn', () => {
+      const config: HookConversionConfig = {
+        name: 'warner',
+        event: 'PreToolUse',
+        action: 'warn',
+        message: 'Warning message',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).toContain('continue: true');
+      expect(script).toContain('WARNING:');
+    });
+
+    it('should output remind JSON for action=remind', () => {
+      const config: HookConversionConfig = {
+        name: 'reminder',
+        event: 'PreToolUse',
+        action: 'remind',
+        message: 'Reminder message',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).toContain('continue: true');
+      expect(script).toContain('REMINDER:');
+    });
+
+    it('should not include tool matching for PreCompact event', () => {
+      const config: HookConversionConfig = {
+        name: 'compact-hook',
+        event: 'PreCompact',
+        action: 'remind',
+        message: 'Save state before compaction',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).not.toContain('TOOL_NAME');
+      expect(script).not.toContain('case');
+    });
+
+    it('should not include tool matching for Notification event', () => {
+      const config: HookConversionConfig = {
+        name: 'notify-hook',
+        event: 'Notification',
+        action: 'remind',
+        message: 'Notification handler',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).not.toContain('TOOL_NAME');
+    });
+
+    it('should not include tool matching for Stop event', () => {
+      const config: HookConversionConfig = {
+        name: 'stop-hook',
+        event: 'Stop',
+        action: 'remind',
+        message: 'Stop handler',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).not.toContain('TOOL_NAME');
+    });
+  });
+
+  describe('constants', () => {
+    it('HOOK_EVENTS should contain all 5 events', () => {
+      expect(HOOK_EVENTS).toEqual([
+        'PreToolUse',
+        'PostToolUse',
+        'PreCompact',
+        'Notification',
+        'Stop',
+      ]);
+    });
+
+    it('ACTION_LEVELS should contain all 3 levels', () => {
+      expect(ACTION_LEVELS).toEqual(['remind', 'warn', 'block']);
+    });
+  });
+
+  describe('validation', () => {
+    it('should reject invalid event', () => {
+      const invalidEvent = 'InvalidEvent';
+      expect(HOOK_EVENTS.includes(invalidEvent as any)).toBe(false);
+    });
+
+    it('should reject invalid action level', () => {
+      const invalidAction = 'destroy';
+      expect(ACTION_LEVELS.includes(invalidAction as any)).toBe(false);
+    });
+
+    it('should accept all valid events', () => {
+      for (const event of HOOK_EVENTS) {
+        expect(HOOK_EVENTS.includes(event)).toBe(true);
+      }
+    });
+
+    it('should accept all valid action levels', () => {
+      for (const action of ACTION_LEVELS) {
+        expect(ACTION_LEVELS.includes(action)).toBe(true);
+      }
+    });
+  });
+
+  describe('directory structure', () => {
+    it('should create correct built-in directory structure', () => {
+      const config: HookConversionConfig = {
+        name: 'test-pack',
+        event: 'PreToolUse',
+        toolMatcher: 'Write',
+        action: 'remind',
+        message: 'Test message',
+      };
+
+      const script = generateHookScript(config);
+      const manifest = generateManifest(config);
+
+      // Simulate built-in output
+      const baseDir = join(tempDir, 'hook-packs', config.name);
+      const scriptsDir = join(baseDir, 'scripts');
+      mkdirSync(scriptsDir, { recursive: true });
+
+      const { writeFileSync: wfs, chmodSync: cms } = require('node:fs');
+      wfs(join(baseDir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+      wfs(join(scriptsDir, `${config.name}.sh`), script);
+      cms(join(scriptsDir, `${config.name}.sh`), 0o755);
+
+      // Verify structure
+      expect(existsSync(join(baseDir, 'manifest.json'))).toBe(true);
+      expect(existsSync(join(scriptsDir, `${config.name}.sh`))).toBe(true);
+
+      // Verify manifest is valid JSON
+      const manifestContent = readFileSync(join(baseDir, 'manifest.json'), 'utf-8');
+      const parsed = JSON.parse(manifestContent);
+      expect(parsed.name).toBe('test-pack');
+      expect(parsed.version).toBe('1.0.0');
+      expect(parsed.scripts).toHaveLength(1);
+      expect(parsed.lifecycleHooks).toHaveLength(1);
+
+      // Verify script content
+      const scriptContent = readFileSync(join(scriptsDir, `${config.name}.sh`), 'utf-8');
+      expect(scriptContent).toContain('#!/bin/sh');
+      expect(scriptContent).toContain('test-pack');
+
+      // Verify script is executable
+      const stat = statSync(join(scriptsDir, `${config.name}.sh`));
+      expect(stat.mode & 0o755).toBe(0o755);
+    });
+
+    it('should create correct project directory structure with --project flag', () => {
+      const config: HookConversionConfig = {
+        name: 'project-hook',
+        event: 'PostToolUse',
+        action: 'warn',
+        message: 'Project-local hook',
+      };
+
+      const script = generateHookScript(config);
+      const manifest = generateManifest(config);
+
+      // Simulate --project output
+      const baseDir = join(tempDir, '.soleri', 'hook-packs', config.name);
+      const scriptsDir = join(baseDir, 'scripts');
+      mkdirSync(scriptsDir, { recursive: true });
+
+      const { writeFileSync: wfs, chmodSync: cms } = require('node:fs');
+      wfs(join(baseDir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+      wfs(join(scriptsDir, `${config.name}.sh`), script);
+      cms(join(scriptsDir, `${config.name}.sh`), 0o755);
+
+      // Verify --project path structure
+      expect(
+        existsSync(join(tempDir, '.soleri', 'hook-packs', 'project-hook', 'manifest.json')),
+      ).toBe(true);
+      expect(
+        existsSync(
+          join(tempDir, '.soleri', 'hook-packs', 'project-hook', 'scripts', 'project-hook.sh'),
+        ),
+      ).toBe(true);
+    });
+  });
+});

package/src/__tests__/validator.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect, vi } from 'vitest';
+import { execSync } from 'node:child_process';
+import { generateFixtures, validateHookScript } from '../hook-packs/validator.js';
+import type { TestFixture } from '../hook-packs/validator.js';
+
+// Mock execSync to avoid needing actual shell scripts in tests
+vi.mock('node:child_process', () => ({
+  execSync: vi.fn(() => ''),
+}));
+
+const mockedExecSync = vi.mocked(execSync);
+
+describe('validator', () => {
+  describe('generateFixtures', () => {
+    it('should return 15 fixtures for PreToolUse (5 matching + 10 non-matching)', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Write');
+      expect(fixtures).toHaveLength(15);
+
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
+      expect(matching).toHaveLength(5);
+      expect(nonMatching).toHaveLength(10);
+    });
+
+    it('should return 15 fixtures for PostToolUse', () => {
+      const fixtures = generateFixtures('PostToolUse', 'Edit|Write');
+      expect(fixtures).toHaveLength(15);
+
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
+      expect(matching).toHaveLength(5);
+      expect(nonMatching).toHaveLength(10);
+    });
+
+    it('should return 15 fixtures for PreCompact', () => {
+      const fixtures = generateFixtures('PreCompact');
+      expect(fixtures).toHaveLength(15);
+
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
+      expect(matching).toHaveLength(5);
+      expect(nonMatching).toHaveLength(10);
+    });
+
+    it('should return 15 fixtures for Notification', () => {
+      const fixtures = generateFixtures('Notification');
+      expect(fixtures).toHaveLength(15);
+    });
+
+    it('should return 15 fixtures for Stop', () => {
+      const fixtures = generateFixtures('Stop');
+      expect(fixtures).toHaveLength(15);
+    });
+
+    it('matching PreToolUse fixtures should have shouldMatch: true', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Bash');
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      for (const f of matching) {
+        expect(f.shouldMatch).toBe(true);
+      }
+    });
+
+    it('non-matching PreToolUse fixtures should have shouldMatch: false', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Write');
+      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
+      for (const f of nonMatching) {
+        expect(f.shouldMatch).toBe(false);
+      }
+    });
+
+    it('PreToolUse matching fixtures should contain tool_name and tool_input', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Write|Edit');
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      for (const f of matching) {
+        expect(f.payload).toHaveProperty('tool_name');
+        expect(f.payload).toHaveProperty('tool_input');
+        const toolInput = f.payload.tool_input as Record<string, unknown>;
+        expect(toolInput).toHaveProperty('file_path');
+        expect(toolInput).toHaveProperty('command');
+      }
+    });
+
+    it('PreToolUse non-matching fixtures should contain tool_name and tool_input', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Write');
+      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
+      for (const f of nonMatching) {
+        expect(f.payload).toHaveProperty('tool_name');
+        expect(f.payload).toHaveProperty('tool_input');
+      }
+    });
+
+    it('should use provided toolMatcher tools in matching fixtures', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Edit|Write');
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      const toolNames = matching.map((f) => f.payload.tool_name);
+      for (const name of toolNames) {
+        expect(['Edit', 'Write']).toContain(name);
+      }
+    });
+
+    it('should default to Write when no toolMatcher provided for PreToolUse', () => {
+      const fixtures = generateFixtures('PreToolUse');
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      for (const f of matching) {
+        expect(f.payload.tool_name).toBe('Write');
+      }
+    });
+
+    it('PreCompact matching fixtures should have session_id', () => {
+      const fixtures = generateFixtures('PreCompact');
+      const matching = fixtures.filter((f) => f.shouldMatch);
+      for (const f of matching) {
+        expect(f.payload).toHaveProperty('session_id');
+        expect(f.payload).toHaveProperty('context');
+      }
+    });
+
+    it('PreCompact non-matching fixtures should have empty payloads', () => {
+      const fixtures = generateFixtures('PreCompact');
+      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
+      for (const f of nonMatching) {
+        expect(Object.keys(f.payload)).toHaveLength(0);
+      }
+    });
+
+    it('all fixtures should have event matching the requested event', () => {
+      for (const event of [
+        'PreToolUse',
+        'PostToolUse',
+        'PreCompact',
+        'Notification',
+        'Stop',
+      ] as const) {
+        const fixtures = generateFixtures(event);
+        for (const f of fixtures) {
+          expect(f.event).toBe(event);
+        }
+      }
+    });
+
+    it('all fixtures should have unique names', () => {
+      const fixtures = generateFixtures('PreToolUse', 'Write|Edit');
+      const names = fixtures.map((f) => f.name);
+      expect(new Set(names).size).toBe(names.length);
+    });
+  });
+
+  describe('validateHookScript', () => {
+    it('should report correctly with a script that produces no output (exit 0)', () => {
+      // execSync mock returns '' (empty string) — no match detected
+      mockedExecSync.mockReturnValue('');
+
+      const fixtures: TestFixture[] = [
+        {
+          name: 'should-match',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Write', tool_input: { file_path: 'test.ts' } },
+          shouldMatch: true,
+        },
+        {
+          name: 'should-not-match',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Read', tool_input: { file_path: 'test.ts' } },
+          shouldMatch: false,
+        },
+      ];
+
+      const report = validateHookScript('/fake/script.sh', fixtures);
+
+      expect(report.total).toBe(2);
+      // Script produces no output, so matched = false for all
+      // should-match expected match but got none -> false negative
+      // should-not-match expected no match and got none -> correct
+      expect(report.falseNegatives).toHaveLength(1);
+      expect(report.falseNegatives[0].fixture.name).toBe('should-match');
+      expect(report.falsePositives).toHaveLength(0);
+      expect(report.passed).toBe(1);
+    });
+
+    it('should detect false positives when script always matches', () => {
+      mockedExecSync.mockReturnValue('{"continue": true, "message": "always matches"}');
+
+      const fixtures: TestFixture[] = [
+        {
+          name: 'should-match',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Write', tool_input: {} },
+          shouldMatch: true,
+        },
+        {
+          name: 'should-not-match',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Read', tool_input: {} },
+          shouldMatch: false,
+        },
+      ];
+
+      const report = validateHookScript('/fake/script.sh', fixtures);
+
+      expect(report.total).toBe(2);
+      // Script always outputs "continue", so matched = true for all
+      // should-not-match expected no match but got one -> false positive
+      expect(report.falsePositives).toHaveLength(1);
+      expect(report.falsePositives[0].fixture.name).toBe('should-not-match');
+      expect(report.falseNegatives).toHaveLength(0);
+      expect(report.passed).toBe(1);
+    });
+
+    it('should report all passed when script matches correctly', () => {
+      mockedExecSync.mockImplementation((cmd: unknown) => {
+        if (typeof cmd === 'string' && cmd.includes('Write')) {
+          return '{"continue": true, "message": "matched"}';
+        }
+        return '';
+      });
+
+      const fixtures: TestFixture[] = [
+        {
+          name: 'should-match',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Write', tool_input: {} },
+          shouldMatch: true,
+        },
+        {
+          name: 'should-not-match',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Read', tool_input: {} },
+          shouldMatch: false,
+        },
+      ];
+
+      const report = validateHookScript('/fake/script.sh', fixtures);
+
+      expect(report.total).toBe(2);
+      expect(report.passed).toBe(2);
+      expect(report.falsePositives).toHaveLength(0);
+      expect(report.falseNegatives).toHaveLength(0);
+    });
+
+    it('should handle script errors gracefully (exit code != 0)', () => {
+      mockedExecSync.mockImplementation(() => {
+        const err = new Error('script failed') as Error & { status: number; stdout: string };
+        err.status = 1;
+        err.stdout = '';
+        throw err;
+      });
+
+      const fixtures: TestFixture[] = [
+        {
+          name: 'error-fixture',
+          event: 'PreToolUse',
+          payload: { tool_name: 'Write', tool_input: {} },
+          shouldMatch: true,
+        },
+      ];
+
+      const report = validateHookScript('/fake/script.sh', fixtures);
+
+      expect(report.total).toBe(1);
+      // Error means matched = false, but shouldMatch = true -> false negative
+      expect(report.falseNegatives).toHaveLength(1);
+      expect(report.passed).toBe(0);
+    });
+  });
+});