vellum 0.2.13 → 0.3.2

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

@@ -1,189 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { mkdirSync, writeFileSync, rmSync, chmodSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-// Set BASE_DATA_DIR before importing modules that use getRootDir()
-const testDir = join(tmpdir(), `hooks-integration-test-${Date.now()}`);
-process.env.BASE_DATA_DIR = testDir;
-
-import { HookManager, resetHookManager } from '../hooks/manager.js';
-import { saveHooksConfig } from '../hooks/config.js';
-
-function createHook(
-  hooksDir: string,
-  name: string,
-  events: string[],
-  scriptContent: string,
-): void {
-  const hookDir = join(hooksDir, name);
-  mkdirSync(hookDir, { recursive: true });
-  writeFileSync(
-    join(hookDir, 'hook.json'),
-    JSON.stringify({
-      name,
-      description: `Integration test hook: ${name}`,
-      version: '1.0.0',
-      events,
-      script: 'run.sh',
-    }),
-  );
-  const scriptPath = join(hookDir, 'run.sh');
-  writeFileSync(scriptPath, scriptContent);
-  chmodSync(scriptPath, 0o755);
-}
-
-describe('Hooks Integration', () => {
-  let hooksDir: string;
-
-  beforeEach(() => {
-    hooksDir = join(testDir, '.vellum', 'workspace', 'hooks');
-    mkdirSync(hooksDir, { recursive: true });
-    resetHookManager();
-  });
-
-  afterEach(() => {
-    resetHookManager();
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  test('hook receives event data via stdin', async () => {
-    const outputFile = join(testDir, 'stdin-data.json');
-    createHook(
-      hooksDir,
-      'stdin-capture',
-      ['pre-tool-execute'],
-      `#!/bin/bash\ncat > "${outputFile}"`,
-    );
-    saveHooksConfig({ version: 1, hooks: { 'stdin-capture': { enabled: true } } });
-
-    const manager = new HookManager();
-    manager.initialize();
-
-    await manager.trigger('pre-tool-execute', {
-      toolName: 'bash',
-      command: 'ls -la',
-      riskLevel: 'medium',
-    });
-
-    // Wait for file write to complete
-    await new Promise((r) => setTimeout(r, 200));
-    const data = JSON.parse(readFileSync(outputFile, 'utf-8'));
-    expect(data.event).toBe('pre-tool-execute');
-    expect(data.toolName).toBe('bash');
-    expect(data.command).toBe('ls -la');
-  });
-
-  test('hook receives environment variables', async () => {
-    const outputFile = join(testDir, 'env-data.txt');
-    createHook(
-      hooksDir,
-      'env-capture',
-      ['daemon-start'],
-      `#!/bin/bash\necho "$VELLUM_HOOK_EVENT|$VELLUM_HOOK_NAME|$VELLUM_ROOT_DIR" > "${outputFile}"`,
-    );
-    saveHooksConfig({ version: 1, hooks: { 'env-capture': { enabled: true } } });
-
-    const manager = new HookManager();
-    manager.initialize();
-
-    await manager.trigger('daemon-start', { pid: 12345 });
-
-    await new Promise((r) => setTimeout(r, 200));
-    const output = readFileSync(outputFile, 'utf-8').trim();
-    const parts = output.split('|');
-    expect(parts[0]).toBe('daemon-start');
-    expect(parts[1]).toBe('env-capture');
-    expect(parts[2]).toContain('.vellum');
-  });
-
-  test('multiple hooks for same event run in order', async () => {
-    const outputFile = join(testDir, 'order.txt');
-    createHook(
-      hooksDir,
-      'hook-c',
-      ['on-error'],
-      `#!/bin/bash\necho "c" >> "${outputFile}"`,
-    );
-    createHook(
-      hooksDir,
-      'hook-a',
-      ['on-error'],
-      `#!/bin/bash\necho "a" >> "${outputFile}"`,
-    );
-    createHook(
-      hooksDir,
-      'hook-b',
-      ['on-error'],
-      `#!/bin/bash\necho "b" >> "${outputFile}"`,
-    );
-    saveHooksConfig({
-      version: 1,
-      hooks: {
-        'hook-a': { enabled: true },
-        'hook-b': { enabled: true },
-        'hook-c': { enabled: true },
-      },
-    });
-
-    const manager = new HookManager();
-    manager.initialize();
-
-    await manager.trigger('on-error', { message: 'test error' });
-
-    await new Promise((r) => setTimeout(r, 200));
-    const lines = readFileSync(outputFile, 'utf-8').trim().split('\n');
-    expect(lines).toEqual(['a', 'b', 'c']);
-  });
-
-  test('hook failure does not prevent subsequent hooks', async () => {
-    const outputFile = join(testDir, 'after-failure.txt');
-    createHook(
-      hooksDir,
-      'hook-fail',
-      ['post-message'],
-      '#!/bin/bash\nexit 1',
-    );
-    createHook(
-      hooksDir,
-      'hook-success',
-      ['post-message'],
-      `#!/bin/bash\necho "ran" > "${outputFile}"`,
-    );
-    saveHooksConfig({
-      version: 1,
-      hooks: {
-        'hook-fail': { enabled: true },
-        'hook-success': { enabled: true },
-      },
-    });
-
-    const manager = new HookManager();
-    manager.initialize();
-
-    await manager.trigger('post-message', {});
-
-    await new Promise((r) => setTimeout(r, 200));
-    const output = readFileSync(outputFile, 'utf-8').trim();
-    expect(output).toBe('ran');
-  });
-
-  test('disabled hooks are not triggered', async () => {
-    const outputFile = join(testDir, 'disabled.txt');
-    createHook(
-      hooksDir,
-      'disabled-hook',
-      ['pre-message'],
-      `#!/bin/bash\necho "should not run" > "${outputFile}"`,
-    );
-    // Not enabled in config (defaults to disabled)
-
-    const manager = new HookManager();
-    manager.initialize();
-
-    await manager.trigger('pre-message', {});
-
-    await new Promise((r) => setTimeout(r, 200));
-    expect(() => readFileSync(outputFile, 'utf-8')).toThrow();
-  });
-});

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

@@ -1,187 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { mkdirSync, writeFileSync, rmSync, chmodSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-// Set BASE_DATA_DIR before importing modules that use getRootDir()
-const testDir = join(tmpdir(), `hooks-manager-test-${Date.now()}`);
-process.env.BASE_DATA_DIR = testDir;
-
-import { HookManager, resetHookManager, getHookManager } from '../hooks/manager.js';
-import { saveHooksConfig } from '../hooks/config.js';
-
-function createHook(
-  hooksDir: string,
-  name: string,
-  events: string[],
-  scriptContent = '#!/bin/bash\nexit 0',
-): void {
-  const hookDir = join(hooksDir, name);
-  mkdirSync(hookDir, { recursive: true });
-  writeFileSync(
-    join(hookDir, 'hook.json'),
-    JSON.stringify({
-      name,
-      description: `Test hook ${name}`,
-      version: '1.0.0',
-      events,
-      script: 'run.sh',
-    }),
-  );
-  const scriptPath = join(hookDir, 'run.sh');
-  writeFileSync(scriptPath, scriptContent);
-  chmodSync(scriptPath, 0o755);
-}
-
-describe('HookManager', () => {
-  let hooksDir: string;
-
-  beforeEach(() => {
-    hooksDir = join(testDir, '.vellum', 'workspace', 'hooks');
-    mkdirSync(hooksDir, { recursive: true });
-    resetHookManager();
-  });
-
-  afterEach(() => {
-    resetHookManager();
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  test('initialize discovers hooks', () => {
-    createHook(hooksDir, 'test-hook', ['on-error']);
-    saveHooksConfig({ version: 1, hooks: { 'test-hook': { enabled: true } } });
-
-    const manager = new HookManager();
-    manager.initialize();
-    expect(manager.getDiscoveredHooks()).toHaveLength(1);
-    expect(manager.getDiscoveredHooks()[0].name).toBe('test-hook');
-  });
-
-  test('initialize returns empty when no hooks', () => {
-    const manager = new HookManager();
-    manager.initialize();
-    expect(manager.getDiscoveredHooks()).toHaveLength(0);
-  });
-
-  test('trigger does nothing for event with no hooks', async () => {
-    const manager = new HookManager();
-    manager.initialize();
-    // Should not throw
-    await manager.trigger('on-error', {});
-  });
-
-  test('trigger runs enabled hooks for matching event', async () => {
-    createHook(hooksDir, 'log-hook', ['pre-tool-execute'], '#!/bin/bash\necho "executed"');
-    saveHooksConfig({ version: 1, hooks: { 'log-hook': { enabled: true } } });
-
-    const manager = new HookManager();
-    manager.initialize();
-    await manager.trigger('pre-tool-execute', { tool: 'Bash' });
-  });
-
-  test('trigger skips disabled hooks', async () => {
-    createHook(hooksDir, 'disabled-hook', ['on-error'], '#!/bin/bash\necho "should not run"');
-    // Not enabled in config (defaults to disabled)
-
-    const manager = new HookManager();
-    manager.initialize();
-    await manager.trigger('on-error', {});
-  });
-
-  test('trigger only runs hooks subscribed to the event', async () => {
-    createHook(hooksDir, 'tool-hook', ['pre-tool-execute'], '#!/bin/bash\necho "tool"');
-    createHook(hooksDir, 'error-hook', ['on-error'], '#!/bin/bash\necho "error"');
-    saveHooksConfig({
-      version: 1,
-      hooks: {
-        'tool-hook': { enabled: true },
-        'error-hook': { enabled: true },
-      },
-    });
-
-    const manager = new HookManager();
-    manager.initialize();
-    await manager.trigger('pre-tool-execute', {});
-  });
-
-  test('trigger runs hooks sequentially in alphabetical order', async () => {
-    // Create hooks that append to a shared file to verify execution order
-    const orderFile = join(testDir, 'order.txt');
-    createHook(hooksDir, 'zebra', ['post-message'], `#!/bin/bash\necho "zebra" >> "${orderFile}"`);
-    createHook(hooksDir, 'alpha', ['post-message'], `#!/bin/bash\necho "alpha" >> "${orderFile}"`);
-    createHook(hooksDir, 'middle', ['post-message'], `#!/bin/bash\necho "middle" >> "${orderFile}"`);
-    saveHooksConfig({
-      version: 1,
-      hooks: {
-        zebra: { enabled: true },
-        alpha: { enabled: true },
-        middle: { enabled: true },
-      },
-    });
-
-    const manager = new HookManager();
-    manager.initialize();
-    await manager.trigger('post-message', {});
-
-    await new Promise((r) => setTimeout(r, 100));
-    const { readFileSync } = await import('node:fs');
-    const order = readFileSync(orderFile, 'utf-8').trim().split('\n');
-    expect(order).toEqual(['alpha', 'middle', 'zebra']);
-  });
-
-  test('trigger handles hook failure gracefully', async () => {
-    createHook(hooksDir, 'bad-hook', ['on-error'], '#!/bin/bash\nexit 1');
-    saveHooksConfig({ version: 1, hooks: { 'bad-hook': { enabled: true } } });
-
-    const manager = new HookManager();
-    manager.initialize();
-    await manager.trigger('on-error', { message: 'test error' });
-  });
-
-  test('getDiscoveredHooks returns a copy', () => {
-    createHook(hooksDir, 'hook-a', ['on-error']);
-    saveHooksConfig({ version: 1, hooks: { 'hook-a': { enabled: true } } });
-
-    const manager = new HookManager();
-    manager.initialize();
-
-    const hooks1 = manager.getDiscoveredHooks();
-    const hooks2 = manager.getDiscoveredHooks();
-    expect(hooks1).toEqual(hooks2);
-    expect(hooks1).not.toBe(hooks2);
-  });
-
-  test('getHookManager returns singleton', () => {
-    const mgr1 = getHookManager();
-    const mgr2 = getHookManager();
-    expect(mgr1).toBe(mgr2);
-  });
-
-  test('resetHookManager clears singleton', () => {
-    const mgr1 = getHookManager();
-    resetHookManager();
-    const mgr2 = getHookManager();
-    expect(mgr1).not.toBe(mgr2);
-  });
-
-  test('multi-event hook is triggered for each subscribed event', async () => {
-    const outputFile = join(testDir, 'multi-event.txt');
-    createHook(
-      hooksDir,
-      'multi',
-      ['pre-tool-execute', 'on-error'],
-      `#!/bin/bash\necho "$VELLUM_HOOK_EVENT" >> "${outputFile}"`,
-    );
-    saveHooksConfig({ version: 1, hooks: { multi: { enabled: true } } });
-
-    const manager = new HookManager();
-    manager.initialize();
-    await manager.trigger('pre-tool-execute', {});
-    await manager.trigger('on-error', {});
-
-    await new Promise((r) => setTimeout(r, 100));
-    const { readFileSync } = await import('node:fs');
-    const events = readFileSync(outputFile, 'utf-8').trim().split('\n');
-    expect(events).toEqual(['pre-tool-execute', 'on-error']);
-  });
-});

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

@@ -1,178 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { mkdirSync, writeFileSync, rmSync, chmodSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-// Set BASE_DATA_DIR before importing modules that use getRootDir()
-const testDir = join(tmpdir(), `hooks-runner-test-${Date.now()}`);
-process.env.BASE_DATA_DIR = testDir;
-
-import { runHookScript } from '../hooks/runner.js';
-import type { DiscoveredHook, HookEventData } from '../hooks/types.js';
-
-function createTestHook(hooksDir: string, name: string, scriptContent: string): DiscoveredHook {
-  const hookDir = join(hooksDir, name);
-  mkdirSync(hookDir, { recursive: true });
-  const scriptPath = join(hookDir, 'run.sh');
-  writeFileSync(scriptPath, scriptContent);
-  chmodSync(scriptPath, 0o755);
-
-  return {
-    name,
-    dir: hookDir,
-    manifest: {
-      name,
-      description: 'Test hook',
-      version: '1.0.0',
-      events: ['pre-tool-execute'],
-      script: 'run.sh',
-    },
-    scriptPath,
-    enabled: true,
-  };
-}
-
-describe('Hook Runner', () => {
-  let hooksDir: string;
-
-  beforeEach(() => {
-    hooksDir = join(testDir, '.vellum', 'workspace', 'hooks');
-    mkdirSync(hooksDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  test('runs a script and captures stdout', async () => {
-    const hook = createTestHook(hooksDir, 'echo-hook', '#!/bin/bash\necho "hello from hook"');
-    const eventData: HookEventData = { event: 'pre-tool-execute' };
-
-    const result = await runHookScript(hook, eventData);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout.trim()).toBe('hello from hook');
-    expect(result.stderr).toBe('');
-  });
-
-  test('captures stderr', async () => {
-    const hook = createTestHook(hooksDir, 'stderr-hook', '#!/bin/bash\necho "error output" >&2');
-    const eventData: HookEventData = { event: 'on-error' };
-
-    const result = await runHookScript(hook, eventData);
-    expect(result.exitCode).toBe(0);
-    expect(result.stderr.trim()).toBe('error output');
-  });
-
-  test('reports non-zero exit code', async () => {
-    const hook = createTestHook(hooksDir, 'fail-hook', '#!/bin/bash\nexit 42');
-    const eventData: HookEventData = { event: 'on-error' };
-
-    const result = await runHookScript(hook, eventData);
-    expect(result.exitCode).toBe(42);
-  });
-
-  test('pipes event data to stdin as JSON', async () => {
-    const hook = createTestHook(hooksDir, 'stdin-hook', '#!/bin/bash\ncat');
-    const eventData: HookEventData = { event: 'pre-tool-execute', tool: 'Bash', command: 'ls' };
-
-    const result = await runHookScript(hook, eventData);
-    expect(result.exitCode).toBe(0);
-    const parsed = JSON.parse(result.stdout);
-    expect(parsed.event).toBe('pre-tool-execute');
-    expect(parsed.tool).toBe('Bash');
-    expect(parsed.command).toBe('ls');
-  });
-
-  test('sets environment variables', async () => {
-    const hook = createTestHook(
-      hooksDir,
-      'env-hook',
-      '#!/bin/bash\necho "$VELLUM_HOOK_EVENT|$VELLUM_HOOK_NAME"',
-    );
-    const eventData: HookEventData = { event: 'post-message' };
-
-    const result = await runHookScript(hook, eventData);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout.trim()).toBe('post-message|env-hook');
-  });
-
-  test('sets VELLUM_ROOT_DIR environment variable', async () => {
-    const hook = createTestHook(hooksDir, 'rootdir-hook', '#!/bin/bash\necho "$VELLUM_ROOT_DIR"');
-    const eventData: HookEventData = { event: 'daemon-start' };
-
-    const result = await runHookScript(hook, eventData);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout.trim()).toContain('.vellum');
-  });
-
-  test('sets VELLUM_WORKSPACE_DIR environment variable', async () => {
-    const hook = createTestHook(hooksDir, 'wsdir-hook', '#!/bin/bash\necho "$VELLUM_WORKSPACE_DIR"');
-    const eventData: HookEventData = { event: 'daemon-start' };
-
-    const result = await runHookScript(hook, eventData);
-    expect(result.exitCode).toBe(0);
-    const wsDir = result.stdout.trim();
-    expect(wsDir).toContain('.vellum');
-    expect(wsDir).toEndWith('workspace');
-  });
-
-  test('sets both VELLUM_ROOT_DIR and VELLUM_WORKSPACE_DIR', async () => {
-    const hook = createTestHook(
-      hooksDir,
-      'both-dirs-hook',
-      '#!/bin/bash\necho "$VELLUM_ROOT_DIR|$VELLUM_WORKSPACE_DIR"',
-    );
-    const eventData: HookEventData = { event: 'pre-tool-execute' };
-
-    const result = await runHookScript(hook, eventData);
-    expect(result.exitCode).toBe(0);
-    const [rootDir, wsDir] = result.stdout.trim().split('|');
-    expect(rootDir).toContain('.vellum');
-    expect(wsDir).toContain('.vellum');
-    expect(wsDir).toEndWith('workspace');
-    // workspace dir should be a subdirectory of root dir
-    expect(wsDir).toStartWith(rootDir);
-  });
-
-  test('[experimental] times out after specified duration', async () => {
-    const hook = createTestHook(hooksDir, 'slow-hook', '#!/bin/bash\nsleep 10');
-    const eventData: HookEventData = { event: 'pre-tool-execute' };
-
-    const result = await runHookScript(hook, eventData, { timeoutMs: 200 });
-    expect(result.exitCode).toBeNull();
-    expect(result.stderr).toContain('Hook timed out');
-  });
-
-  test('handles non-existent script gracefully', async () => {
-    const hook: DiscoveredHook = {
-      name: 'missing-script',
-      dir: join(hooksDir, 'missing-script'),
-      manifest: {
-        name: 'missing-script',
-        description: 'Missing',
-        version: '1.0.0',
-        events: ['on-error'],
-        script: 'nonexistent.sh',
-      },
-      scriptPath: join(hooksDir, 'missing-script', 'nonexistent.sh'),
-      enabled: true,
-    };
-    mkdirSync(hook.dir, { recursive: true });
-    const eventData: HookEventData = { event: 'on-error' };
-
-    const result = await runHookScript(hook, eventData);
-    expect(result.exitCode).toBeNull();
-    expect(result.stderr).toBeTruthy();
-  });
-
-  test('runs script in hook directory as cwd', async () => {
-    const hook = createTestHook(hooksDir, 'cwd-hook', '#!/bin/bash\npwd -P');
-    const eventData: HookEventData = { event: 'pre-tool-execute' };
-
-    const result = await runHookScript(hook, eventData);
-    expect(result.exitCode).toBe(0);
-    // Use realpathSync to resolve macOS /var -> /private/var symlinks
-    const { realpathSync } = await import('node:fs');
-    expect(result.stdout.trim()).toBe(realpathSync(hook.dir));
-  });
-});