@vellumai/assistant 0.6.5 → 0.6.6

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

@@ -1,175 +0,0 @@
-import { chmodSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-// Set VELLUM_WORKSPACE_DIR before importing modules that use platform helpers
-const testDir = join(tmpdir(), `hooks-runner-test-${Date.now()}`);
-process.env.VELLUM_WORKSPACE_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, "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.length).toBeGreaterThan(0);
-    expect(wsDir).toBe(testDir);
-  });
-
-  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));
-  });
-});

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

@@ -1,160 +0,0 @@
-import {
-  chmodSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-// Set VELLUM_WORKSPACE_DIR before importing modules that use platform helpers
-const testDir = join(tmpdir(), `hooks-settings-test-${Date.now()}`);
-process.env.VELLUM_WORKSPACE_DIR = testDir;
-
-import { getHookSettings } from "../hooks/config.js";
-import { saveHooksConfig } from "../hooks/config.js";
-import { runHookScript } from "../hooks/runner.js";
-import type { DiscoveredHook, HookManifest } from "../hooks/types.js";
-
-describe("Hook Settings", () => {
-  let hooksDir: string;
-
-  beforeEach(() => {
-    hooksDir = join(testDir, "hooks");
-    mkdirSync(hooksDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  test("getHookSettings returns empty object when no schema and no config", () => {
-    const manifest: HookManifest = {
-      name: "test",
-      description: "Test",
-      version: "1.0.0",
-      events: ["on-error"],
-      script: "run.sh",
-    };
-
-    const settings = getHookSettings("test", manifest);
-    expect(settings).toEqual({});
-  });
-
-  test("getHookSettings returns defaults from manifest schema", () => {
-    const manifest: HookManifest = {
-      name: "test",
-      description: "Test",
-      version: "1.0.0",
-      events: ["on-error"],
-      script: "run.sh",
-      settingsSchema: {
-        maxLen: { type: "number", default: 2000, description: "Max length" },
-        verbose: { type: "boolean", default: false },
-      },
-    };
-
-    const settings = getHookSettings("test", manifest);
-    expect(settings.maxLen).toBe(2000);
-    expect(settings.verbose).toBe(false);
-  });
-
-  test("getHookSettings merges user overrides over defaults", () => {
-    const manifest: HookManifest = {
-      name: "test",
-      description: "Test",
-      version: "1.0.0",
-      events: ["on-error"],
-      script: "run.sh",
-      settingsSchema: {
-        maxLen: { type: "number", default: 2000 },
-        verbose: { type: "boolean", default: false },
-      },
-    };
-
-    saveHooksConfig({
-      version: 1,
-      hooks: {
-        test: {
-          enabled: true,
-          settings: { maxLen: 5000 },
-        },
-      },
-    });
-
-    const settings = getHookSettings("test", manifest);
-    expect(settings.maxLen).toBe(5000); // Overridden
-    expect(settings.verbose).toBe(false); // Default preserved
-  });
-
-  test("getHookSettings allows user settings without schema", () => {
-    const manifest: HookManifest = {
-      name: "test",
-      description: "Test",
-      version: "1.0.0",
-      events: ["on-error"],
-      script: "run.sh",
-    };
-
-    saveHooksConfig({
-      version: 1,
-      hooks: {
-        test: {
-          enabled: true,
-          settings: { customKey: "customValue" },
-        },
-      },
-    });
-
-    const settings = getHookSettings("test", manifest);
-    expect(settings.customKey).toBe("customValue");
-  });
-
-  test("VELLUM_HOOK_SETTINGS env var is passed to script", async () => {
-    const hookDir = join(hooksDir, "settings-hook");
-    mkdirSync(hookDir, { recursive: true });
-
-    const manifest: HookManifest = {
-      name: "settings-hook",
-      description: "Settings test",
-      version: "1.0.0",
-      events: ["on-error"],
-      script: "run.sh",
-      settingsSchema: {
-        greeting: { type: "string", default: "hello" },
-      },
-    };
-    writeFileSync(join(hookDir, "hook.json"), JSON.stringify(manifest));
-
-    const outputFile = join(testDir, "settings-output.txt");
-    const scriptContent = `#!/bin/bash\necho "$VELLUM_HOOK_SETTINGS" > "${outputFile}"`;
-    writeFileSync(join(hookDir, "run.sh"), scriptContent);
-    chmodSync(join(hookDir, "run.sh"), 0o755);
-
-    saveHooksConfig({
-      version: 1,
-      hooks: {
-        "settings-hook": {
-          enabled: true,
-          settings: { greeting: "world" },
-        },
-      },
-    });
-
-    const hook: DiscoveredHook = {
-      name: "settings-hook",
-      dir: hookDir,
-      manifest,
-      scriptPath: join(hookDir, "run.sh"),
-      enabled: true,
-    };
-
-    await runHookScript(hook, { event: "on-error" });
-
-    await new Promise((r) => setTimeout(r, 200));
-    const output = JSON.parse(readFileSync(outputFile, "utf-8").trim());
-    expect(output.greeting).toBe("world"); // User override
-  });
-});

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

@@ -1,169 +0,0 @@
-import {
-  chmodSync,
-  cpSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-// Set VELLUM_WORKSPACE_DIR before importing modules that use platform helpers
-const testDir = join(tmpdir(), `hooks-templates-test-${Date.now()}`);
-process.env.VELLUM_WORKSPACE_DIR = testDir;
-
-import {
-  ensureHookInConfig,
-  loadHooksConfig,
-  setHookEnabled,
-} from "../hooks/config.js";
-import { installTemplates } from "../hooks/templates.js";
-
-/**
- * Create a fake hook-templates directory structure that mimics
- * the bundled templates at `assistant/hook-templates/`.
- */
-function createTemplateDir(
-  templatesDir: string,
-  name: string,
-  manifest: Record<string, unknown>,
-  scriptContent = "#!/bin/bash\nexit 0",
-): void {
-  const dir = join(templatesDir, name);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "hook.json"), JSON.stringify(manifest));
-  const scriptName = (manifest.script as string) ?? "run.sh";
-  writeFileSync(join(dir, scriptName), scriptContent);
-}
-
-describe("Hook Templates", () => {
-  let hooksDir: string;
-
-  beforeEach(() => {
-    hooksDir = join(testDir, "hooks");
-    mkdirSync(hooksDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  test("installs template to hooks directory", () => {
-    // installTemplates looks relative to its own file location.
-    // We'll test by creating a template in the actual hook-templates dir
-    // and verifying the installer's behavior through the public API.
-    // For unit testing, we test the core logic directly.
-
-    // Create a mock templates directory
-    const templatesDir = join(testDir, "hook-templates");
-    createTemplateDir(templatesDir, "test-hook", {
-      name: "test-hook",
-      description: "A test template",
-      version: "1.0.0",
-      events: ["on-error"],
-      script: "run.sh",
-    });
-
-    // Manually simulate what installTemplates does
-    const entries = readdirSync(templatesDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const targetDir = join(hooksDir, entry.name);
-      if (existsSync(targetDir)) continue;
-      cpSync(join(templatesDir, entry.name), targetDir, { recursive: true });
-      const manifestPath = join(targetDir, "hook.json");
-      const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-      if (manifest.script) {
-        chmodSync(join(targetDir, manifest.script), 0o755);
-      }
-    }
-
-    expect(existsSync(join(hooksDir, "test-hook", "hook.json"))).toBe(true);
-    expect(existsSync(join(hooksDir, "test-hook", "run.sh"))).toBe(true);
-
-    // Check script is executable
-    const stat = statSync(join(hooksDir, "test-hook", "run.sh"));
-    expect((stat.mode & 0o111) !== 0).toBe(true);
-  });
-
-  test("does not overwrite existing hooks", () => {
-    // Pre-create a hook with custom content
-    const existingHookDir = join(hooksDir, "existing-hook");
-    mkdirSync(existingHookDir, { recursive: true });
-    writeFileSync(
-      join(existingHookDir, "hook.json"),
-      JSON.stringify({
-        name: "existing-hook",
-        description: "User-modified hook",
-        version: "2.0.0",
-        events: ["on-error"],
-        script: "run.sh",
-      }),
-    );
-    writeFileSync(
-      join(existingHookDir, "run.sh"),
-      '#!/bin/bash\necho "custom"',
-    );
-
-    // Create a template with the same name but different content
-    const templatesDir = join(testDir, "hook-templates");
-    createTemplateDir(
-      templatesDir,
-      "existing-hook",
-      {
-        name: "existing-hook",
-        description: "Template version",
-        version: "1.0.0",
-        events: ["on-error"],
-        script: "run.sh",
-      },
-      '#!/bin/bash\necho "template"',
-    );
-
-    // Simulate install — should skip
-    const entries = readdirSync(templatesDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const targetDir = join(hooksDir, entry.name);
-      if (existsSync(targetDir)) continue; // Should skip
-      cpSync(join(templatesDir, entry.name), targetDir, { recursive: true });
-    }
-
-    // Verify original content preserved
-    const manifest = JSON.parse(
-      readFileSync(join(existingHookDir, "hook.json"), "utf-8"),
-    );
-    expect(manifest.version).toBe("2.0.0");
-    expect(manifest.description).toBe("User-modified hook");
-  });
-
-  test("installTemplates runs without error when no templates dir exists", () => {
-    // installTemplates should gracefully handle missing templates dir
-    // This tests the guard: if (!existsSync(templatesDir)) return;
-    expect(() => installTemplates()).not.toThrow();
-  });
-
-  test("config entry is added for installed template", () => {
-    // Manually install a template and call ensureHookInConfig
-    ensureHookInConfig("new-template", { enabled: false });
-
-    const config = loadHooksConfig();
-    expect(config.hooks["new-template"]).toEqual({ enabled: false });
-  });
-
-  test("config entry preserves existing enabled state", () => {
-    // Set hook as enabled first
-    setHookEnabled("my-hook", true);
-
-    // ensureHookInConfig should not overwrite
-    ensureHookInConfig("my-hook", { enabled: false });
-
-    const config = loadHooksConfig();
-    expect(config.hooks["my-hook"].enabled).toBe(true);
-  });
-});

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

@@ -1,170 +0,0 @@
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { runHookScript } from "../hooks/runner.js";
-import type {
-  DiscoveredHook,
-  HookEventData,
-  HookManifest,
-} from "../hooks/types.js";
-
-let hooksDir: string;
-
-function createHook(
-  name: string,
-  scriptName: string,
-  scriptContent: string,
-): DiscoveredHook {
-  const hookDir = join(hooksDir, name);
-  mkdirSync(hookDir, { recursive: true });
-
-  const manifest: HookManifest = {
-    name,
-    description: `Test hook: ${name}`,
-    version: "1.0.0",
-    events: ["pre-llm-call"],
-    script: scriptName,
-  };
-
-  writeFileSync(join(hookDir, "hook.json"), JSON.stringify(manifest));
-
-  const scriptPath = join(hookDir, scriptName);
-  writeFileSync(scriptPath, scriptContent, { mode: 0o755 });
-
-  return {
-    name,
-    dir: hookDir,
-    manifest,
-    scriptPath,
-    enabled: true,
-  };
-}
-
-describe("TypeScript hooks runner", () => {
-  beforeEach(() => {
-    hooksDir = join(
-      tmpdir(),
-      `hooks-ts-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    mkdirSync(hooksDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(hooksDir, { recursive: true, force: true });
-  });
-
-  test("[experimental] runs .ts hook via bun run", async () => {
-    const hook = createHook(
-      "ts-hook",
-      "run.ts",
-      `
-const chunks: Buffer[] = [];
-for await (const chunk of Bun.stdin.stream()) {
-  chunks.push(Buffer.from(chunk));
-}
-const data = JSON.parse(Buffer.concat(chunks).toString('utf-8'));
-console.log(JSON.stringify({ event: data.event, ok: true }));
-`,
-    );
-
-    const eventData: HookEventData = { event: "pre-llm-call", model: "test" };
-    const result = await runHookScript(hook, eventData);
-
-    expect(result.exitCode).toBe(0);
-    const output = JSON.parse(result.stdout.trim());
-    expect(output.event).toBe("pre-llm-call");
-    expect(output.ok).toBe(true);
-  });
-
-  test("[experimental] .ts hook receives event data on stdin", async () => {
-    const hook = createHook(
-      "stdin-hook",
-      "handler.ts",
-      `
-const chunks: Buffer[] = [];
-for await (const chunk of Bun.stdin.stream()) {
-  chunks.push(Buffer.from(chunk));
-}
-const data = JSON.parse(Buffer.concat(chunks).toString('utf-8'));
-console.log(data.customField);
-`,
-    );
-
-    const eventData: HookEventData = {
-      event: "pre-llm-call",
-      customField: "hello-ts",
-    };
-    const result = await runHookScript(hook, eventData);
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout.trim()).toBe("hello-ts");
-  });
-
-  test(".ts hook receives env vars", async () => {
-    const hook = createHook(
-      "env-hook",
-      "check-env.ts",
-      `
-console.log(process.env.VELLUM_HOOK_EVENT);
-console.log(process.env.VELLUM_HOOK_NAME);
-`,
-    );
-
-    const eventData: HookEventData = { event: "pre-llm-call" };
-    const result = await runHookScript(hook, eventData);
-
-    expect(result.exitCode).toBe(0);
-    const lines = result.stdout.trim().split("\n");
-    expect(lines[0]).toBe("pre-llm-call");
-    expect(lines[1]).toBe("env-hook");
-  });
-
-  test(".ts hook non-zero exit returns exit code", async () => {
-    const hook = createHook(
-      "fail-hook",
-      "fail.ts",
-      `
-process.exit(1);
-`,
-    );
-
-    const eventData: HookEventData = { event: "pre-llm-call" };
-    const result = await runHookScript(hook, eventData);
-
-    expect(result.exitCode).toBe(1);
-  });
-
-  test(".sh hook still runs directly (not via bun)", async () => {
-    const hook = createHook(
-      "sh-hook",
-      "run.sh",
-      `#!/bin/sh
-echo "shell-hook"
-`,
-    );
-
-    const eventData: HookEventData = { event: "pre-llm-call" };
-    const result = await runHookScript(hook, eventData);
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout.trim()).toBe("shell-hook");
-  });
-
-  test(".ts hook can write to stderr", async () => {
-    const hook = createHook(
-      "stderr-hook",
-      "log.ts",
-      `
-console.error('ts-stderr-output');
-`,
-    );
-
-    const eventData: HookEventData = { event: "pre-llm-call" };
-    const result = await runHookScript(hook, eventData);
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stderr).toContain("ts-stderr-output");
-  });
-});