@vellumai/assistant 0.6.5 → 0.6.6

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

@@ -1,211 +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";
-
-import { saveHooksConfig } from "../hooks/config.js";
-import { discoverHooks } from "../hooks/discovery.js";
-
-// Set VELLUM_WORKSPACE_DIR before importing modules that use platform helpers
-const testDir = join(tmpdir(), `hooks-discovery-test-${Date.now()}`);
-process.env.VELLUM_WORKSPACE_DIR = testDir;
-
-function createHook(
-  hooksDir: string,
-  name: string,
-  manifest: Record<string, unknown>,
-  scriptContent = "#!/bin/bash\nexit 0",
-): void {
-  const hookDir = join(hooksDir, name);
-  mkdirSync(hookDir, { recursive: true });
-  writeFileSync(join(hookDir, "hook.json"), JSON.stringify(manifest));
-  const scriptName = (manifest.script as string) ?? "run.sh";
-  const scriptPath = join(hookDir, scriptName);
-  writeFileSync(scriptPath, scriptContent);
-  chmodSync(scriptPath, 0o755);
-}
-
-describe("Hooks Discovery", () => {
-  let hooksDir: string;
-
-  beforeEach(() => {
-    hooksDir = join(testDir, "hooks");
-    mkdirSync(hooksDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  test("returns empty array when no hooks exist", () => {
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toEqual([]);
-  });
-
-  test("discovers a valid hook", () => {
-    createHook(hooksDir, "my-hook", {
-      name: "my-hook",
-      description: "Test hook",
-      version: "1.0.0",
-      events: ["pre-tool-execute"],
-      script: "run.sh",
-    });
-
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toHaveLength(1);
-    expect(hooks[0].name).toBe("my-hook");
-    expect(hooks[0].manifest.events).toEqual(["pre-tool-execute"]);
-    expect(hooks[0].enabled).toBe(false);
-  });
-
-  test("discovers multiple hooks sorted alphabetically", () => {
-    createHook(hooksDir, "zebra-hook", {
-      name: "zebra-hook",
-      description: "Z hook",
-      version: "1.0.0",
-      events: ["on-error"],
-      script: "run.sh",
-    });
-    createHook(hooksDir, "alpha-hook", {
-      name: "alpha-hook",
-      description: "A hook",
-      version: "1.0.0",
-      events: ["post-message"],
-      script: "run.sh",
-    });
-
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toHaveLength(2);
-    expect(hooks[0].name).toBe("alpha-hook");
-    expect(hooks[1].name).toBe("zebra-hook");
-  });
-
-  test("skips directory without hook.json", () => {
-    mkdirSync(join(hooksDir, "no-manifest"), { recursive: true });
-    writeFileSync(
-      join(hooksDir, "no-manifest", "run.sh"),
-      "#!/bin/bash\nexit 0",
-    );
-
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toEqual([]);
-  });
-
-  test("skips hook with invalid JSON in manifest", () => {
-    const hookDir = join(hooksDir, "bad-json");
-    mkdirSync(hookDir, { recursive: true });
-    writeFileSync(join(hookDir, "hook.json"), "NOT JSON {{{");
-    writeFileSync(join(hookDir, "run.sh"), "#!/bin/bash\nexit 0");
-
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toEqual([]);
-  });
-
-  test("skips hook with missing required fields", () => {
-    createHook(hooksDir, "missing-fields", {
-      name: "missing-fields",
-      // missing events and script
-    });
-
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toEqual([]);
-  });
-
-  test("skips hook with invalid event names", () => {
-    createHook(hooksDir, "bad-events", {
-      name: "bad-events",
-      description: "Bad",
-      version: "1.0.0",
-      events: ["not-a-real-event"],
-      script: "run.sh",
-    });
-
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toEqual([]);
-  });
-
-  test("skips hook with missing script file", () => {
-    const hookDir = join(hooksDir, "no-script");
-    mkdirSync(hookDir, { recursive: true });
-    writeFileSync(
-      join(hookDir, "hook.json"),
-      JSON.stringify({
-        name: "no-script",
-        description: "Missing script",
-        version: "1.0.0",
-        events: ["on-error"],
-        script: "nonexistent.sh",
-      }),
-    );
-
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toEqual([]);
-  });
-
-  test("respects enabled state from config", () => {
-    createHook(hooksDir, "enabled-hook", {
-      name: "enabled-hook",
-      description: "Enabled",
-      version: "1.0.0",
-      events: ["pre-tool-execute"],
-      script: "run.sh",
-    });
-
-    saveHooksConfig({
-      version: 1,
-      hooks: { "enabled-hook": { enabled: true } },
-    });
-
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toHaveLength(1);
-    expect(hooks[0].enabled).toBe(true);
-  });
-
-  test("defaults to disabled when not in config", () => {
-    createHook(hooksDir, "unconfigured", {
-      name: "unconfigured",
-      description: "Not in config",
-      version: "1.0.0",
-      events: ["on-error"],
-      script: "run.sh",
-    });
-
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks[0].enabled).toBe(false);
-  });
-
-  test("returns empty for nonexistent hooks directory", () => {
-    const hooks = discoverHooks("/nonexistent/path");
-    expect(hooks).toEqual([]);
-  });
-
-  test("skips non-directory entries", () => {
-    writeFileSync(join(hooksDir, "some-file.txt"), "not a directory");
-
-    createHook(hooksDir, "valid-hook", {
-      name: "valid-hook",
-      description: "Valid",
-      version: "1.0.0",
-      events: ["on-error"],
-      script: "run.sh",
-    });
-
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toHaveLength(1);
-    expect(hooks[0].name).toBe("valid-hook");
-  });
-
-  test("hook with multiple events is discovered", () => {
-    createHook(hooksDir, "multi-event", {
-      name: "multi-event",
-      description: "Multi",
-      version: "1.0.0",
-      events: ["pre-tool-execute", "post-tool-execute", "on-error"],
-      script: "run.sh",
-    });
-
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toHaveLength(1);
-    expect(hooks[0].manifest.events).toHaveLength(3);
-  });
-});

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

@@ -1,196 +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 getWorkspaceDir()
-const testDir = join(tmpdir(), `hooks-integration-test-${Date.now()}`);
-process.env.VELLUM_WORKSPACE_DIR = testDir;
-
-import { saveHooksConfig } from "../hooks/config.js";
-import { HookManager, resetHookManager } from "../hooks/manager.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, "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_WORKSPACE_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]).toBe(testDir);
-  });
-
-  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,226 +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 getWorkspaceDir()
-const testDir = join(tmpdir(), `hooks-manager-test-${Date.now()}`);
-process.env.VELLUM_WORKSPACE_DIR = testDir;
-
-import { saveHooksConfig } from "../hooks/config.js";
-import {
-  getHookManager,
-  HookManager,
-  resetHookManager,
-} from "../hooks/manager.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, "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"]);
-  });
-});