@vellumai/assistant 0.6.5 → 0.6.6

package/src/__tests__/context-overflow-approval.test.ts

@@ -1,156 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
-import {
-  CONTEXT_OVERFLOW_TOOL_NAME,
-  requestCompressionApproval,
-} from "../daemon/context-overflow-approval.js";
-import type { PermissionPrompter } from "../permissions/prompter.js";
-import type { UserDecision } from "../permissions/types.js";
-
-function createMockPrompter(decision: UserDecision): PermissionPrompter {
-  const promptFn = mock(() =>
-    Promise.resolve({
-      decision,
-      selectedPattern: undefined,
-      selectedScope: undefined,
-      decisionContext: undefined,
-    }),
-  );
-  return { prompt: promptFn } as unknown as PermissionPrompter;
-}
-
-describe("requestCompressionApproval", () => {
-  beforeEach(() => {
-    _setOverridesForTesting({});
-  });
-
-  // ── Prompt shape ──
-
-  test("auto-approves without prompting under v2", async () => {
-    _setOverridesForTesting({ "permission-controls-v2": true });
-
-    const prompter = createMockPrompter("deny");
-    const result = await requestCompressionApproval(prompter);
-
-    expect(result).toEqual({ approved: true });
-    expect(prompter.prompt).not.toHaveBeenCalled();
-  });
-
-  test("uses the reserved pseudo tool name", async () => {
-    const prompter = createMockPrompter("allow");
-    await requestCompressionApproval(prompter);
-
-    expect(prompter.prompt).toHaveBeenCalledTimes(1);
-    const args = (prompter.prompt as ReturnType<typeof mock>).mock.calls[0];
-    expect(args[0]).toBe(CONTEXT_OVERFLOW_TOOL_NAME);
-  });
-
-  test("passes low risk level", async () => {
-    const prompter = createMockPrompter("allow");
-    await requestCompressionApproval(prompter);
-
-    const args = (prompter.prompt as ReturnType<typeof mock>).mock.calls[0];
-    // riskLevel is the 3rd argument (index 2)
-    expect(args[2]).toBe("low");
-  });
-
-  test("provides empty allowlist and scope options", async () => {
-    const prompter = createMockPrompter("allow");
-    await requestCompressionApproval(prompter);
-
-    const args = (prompter.prompt as ReturnType<typeof mock>).mock.calls[0];
-    // allowlistOptions (index 3) and scopeOptions (index 4)
-    expect(args[3]).toEqual([]);
-    expect(args[4]).toEqual([]);
-  });
-
-  test("sets persistentDecisionsAllowed to false", async () => {
-    const prompter = createMockPrompter("allow");
-    await requestCompressionApproval(prompter);
-
-    const args = (prompter.prompt as ReturnType<typeof mock>).mock.calls[0];
-    // persistentDecisionsAllowed is index 8
-    expect(args[8]).toBe(false);
-  });
-
-  test("includes a description in the input", async () => {
-    const prompter = createMockPrompter("allow");
-    await requestCompressionApproval(prompter);
-
-    const args = (prompter.prompt as ReturnType<typeof mock>).mock.calls[0];
-    // input is the 2nd argument (index 1)
-    const input = args[1] as Record<string, unknown>;
-    expect(typeof input.description).toBe("string");
-    expect((input.description as string).length).toBeGreaterThan(0);
-  });
-
-  // ── Decision mapping ──
-
-  test("maps allow decision to approved: true", async () => {
-    const prompter = createMockPrompter("allow");
-    const result = await requestCompressionApproval(prompter);
-    expect(result).toEqual({ approved: true });
-  });
-
-  test("maps deny decision to approved: false", async () => {
-    const prompter = createMockPrompter("deny");
-    const result = await requestCompressionApproval(prompter);
-    expect(result).toEqual({ approved: false });
-  });
-
-  test("maps always_deny decision to approved: false", async () => {
-    const prompter = createMockPrompter("always_deny");
-    const result = await requestCompressionApproval(prompter);
-    expect(result).toEqual({ approved: false });
-  });
-
-  test("maps always_allow decision to approved: true", async () => {
-    const prompter = createMockPrompter("always_allow");
-    const result = await requestCompressionApproval(prompter);
-    expect(result).toEqual({ approved: true });
-  });
-
-  test("maps allow_10m decision to approved: true", async () => {
-    const prompter = createMockPrompter("allow_10m");
-    const result = await requestCompressionApproval(prompter);
-    expect(result).toEqual({ approved: true });
-  });
-
-  test("maps allow_conversation decision to approved: true", async () => {
-    const prompter = createMockPrompter("allow_conversation");
-    const result = await requestCompressionApproval(prompter);
-    expect(result).toEqual({ approved: true });
-  });
-
-  // ── Signal forwarding ──
-
-  test("forwards abort signal to prompter", async () => {
-    const controller = new AbortController();
-    const prompter = createMockPrompter("allow");
-
-    await requestCompressionApproval(prompter, {
-      signal: controller.signal,
-    });
-
-    const args = (prompter.prompt as ReturnType<typeof mock>).mock.calls[0];
-    // signal is index 9
-    expect(args[9]).toBe(controller.signal);
-  });
-
-  test("works without signal option", async () => {
-    const prompter = createMockPrompter("allow");
-    const result = await requestCompressionApproval(prompter);
-    expect(result).toEqual({ approved: true });
-
-    const args = (prompter.prompt as ReturnType<typeof mock>).mock.calls[0];
-    // signal should be undefined when not provided
-    expect(args[9]).toBeUndefined();
-  });
-
-  // ── Tool name constant ──
-
-  test("CONTEXT_OVERFLOW_TOOL_NAME is context_overflow_compression", () => {
-    expect(CONTEXT_OVERFLOW_TOOL_NAME).toBe("context_overflow_compression");
-  });
-});

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

@@ -1,178 +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-blocking-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,
-  blocking = false,
-): 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",
-      ...(blocking ? { blocking: true } : {}),
-    }),
-  );
-  const scriptPath = join(hookDir, "run.sh");
-  writeFileSync(scriptPath, scriptContent);
-  chmodSync(scriptPath, 0o755);
-}
-
-describe("Blocking Hooks", () => {
-  let hooksDir: string;
-
-  beforeEach(() => {
-    hooksDir = join(testDir, "hooks");
-    mkdirSync(hooksDir, { recursive: true });
-    resetHookManager();
-  });
-
-  afterEach(() => {
-    resetHookManager();
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  test("blocking hook on pre-* event cancels action on non-zero exit", async () => {
-    createHook(
-      hooksDir,
-      "guard",
-      ["pre-tool-execute"],
-      "#!/bin/bash\nexit 1",
-      true,
-    );
-    saveHooksConfig({ version: 1, hooks: { guard: { enabled: true } } });
-
-    const manager = new HookManager();
-    manager.initialize();
-
-    const result = await manager.trigger("pre-tool-execute", {
-      toolName: "bash",
-    });
-    expect(result.blocked).toBe(true);
-    expect(result.blockedBy).toBe("guard");
-  });
-
-  test("blocking hook on pre-* event allows action on zero exit", async () => {
-    createHook(
-      hooksDir,
-      "pass-guard",
-      ["pre-tool-execute"],
-      "#!/bin/bash\nexit 0",
-      true,
-    );
-    saveHooksConfig({ version: 1, hooks: { "pass-guard": { enabled: true } } });
-
-    const manager = new HookManager();
-    manager.initialize();
-
-    const result = await manager.trigger("pre-tool-execute", {
-      toolName: "bash",
-    });
-    expect(result.blocked).toBe(false);
-  });
-
-  test("non-blocking hook does not cancel even on non-zero exit", async () => {
-    createHook(
-      hooksDir,
-      "logger",
-      ["pre-tool-execute"],
-      "#!/bin/bash\nexit 1",
-      false,
-    );
-    saveHooksConfig({ version: 1, hooks: { logger: { enabled: true } } });
-
-    const manager = new HookManager();
-    manager.initialize();
-
-    const result = await manager.trigger("pre-tool-execute", {
-      toolName: "bash",
-    });
-    expect(result.blocked).toBe(false);
-  });
-
-  test("blocking hook on non-pre event does not cancel", async () => {
-    createHook(
-      hooksDir,
-      "post-guard",
-      ["post-tool-execute"],
-      "#!/bin/bash\nexit 1",
-      true,
-    );
-    saveHooksConfig({ version: 1, hooks: { "post-guard": { enabled: true } } });
-
-    const manager = new HookManager();
-    manager.initialize();
-
-    const result = await manager.trigger("post-tool-execute", {
-      toolName: "bash",
-    });
-    expect(result.blocked).toBe(false);
-  });
-
-  test("blocking hook stops subsequent hooks from running", async () => {
-    const outputFile = join(testDir, "after-block.txt");
-    createHook(
-      hooksDir,
-      "blocker",
-      ["pre-llm-call"],
-      "#!/bin/bash\nexit 1",
-      true,
-    );
-    createHook(
-      hooksDir,
-      "logger",
-      ["pre-llm-call"],
-      `#!/bin/bash\necho "ran" > "${outputFile}"`,
-      false,
-    );
-    saveHooksConfig({
-      version: 1,
-      hooks: {
-        blocker: { enabled: true },
-        logger: { enabled: true },
-      },
-    });
-
-    const manager = new HookManager();
-    manager.initialize();
-
-    const result = await manager.trigger("pre-llm-call", {});
-    expect(result.blocked).toBe(true);
-    expect(result.blockedBy).toBe("blocker");
-
-    // Logger should NOT have run because blocker runs first (alphabetical order)
-    await new Promise((r) => setTimeout(r, 100));
-    expect(() => readFileSync(outputFile, "utf-8")).toThrow();
-  });
-
-  test("trigger returns not blocked when no hooks match", async () => {
-    const manager = new HookManager();
-    manager.initialize();
-
-    const result = await manager.trigger("pre-tool-execute", {});
-    expect(result.blocked).toBe(false);
-  });
-});

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

@@ -1,182 +0,0 @@
-import {
-  chmodSync,
-  cpSync,
-  existsSync,
-  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";
-
-import { discoverHooks } from "../hooks/discovery.js";
-
-let hooksDir: string;
-
-function makeManifest(
-  name: string,
-  events: string[] = ["pre-llm-call"],
-  extra: Record<string, unknown> = {},
-): string {
-  return JSON.stringify({
-    name,
-    description: `Test hook: ${name}`,
-    version: "1.0.0",
-    events,
-    script: "run.sh",
-    ...extra,
-  });
-}
-
-function installHook(
-  name: string,
-  events: string[] = ["pre-llm-call"],
-  extra: Record<string, unknown> = {},
-): void {
-  const hookDir = join(hooksDir, name);
-  mkdirSync(hookDir, { recursive: true });
-  writeFileSync(join(hookDir, "hook.json"), makeManifest(name, events, extra));
-  writeFileSync(join(hookDir, "run.sh"), "#!/bin/sh\nexit 0\n", {
-    mode: 0o755,
-  });
-}
-
-describe("hooks CLI operations", () => {
-  beforeEach(() => {
-    hooksDir = join(
-      tmpdir(),
-      `hooks-cli-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    mkdirSync(hooksDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(hooksDir, { recursive: true, force: true });
-  });
-
-  test("discoverHooks lists installed hooks", () => {
-    installHook("hook-a", ["pre-llm-call"]);
-    installHook("hook-b", ["post-tool-execute", "pre-tool-execute"]);
-
-    const hooks = discoverHooks(hooksDir);
-
-    expect(hooks).toHaveLength(2);
-    expect(hooks[0].name).toBe("hook-a");
-    expect(hooks[0].manifest.events).toEqual(["pre-llm-call"]);
-    expect(hooks[1].name).toBe("hook-b");
-    expect(hooks[1].manifest.events).toEqual([
-      "post-tool-execute",
-      "pre-tool-execute",
-    ]);
-  });
-
-  test("discoverHooks returns empty when no hooks", () => {
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toHaveLength(0);
-  });
-
-  test("enable/disable toggles hook config", () => {
-    // Write a config.json in hooksDir
-    const configPath = join(hooksDir, "config.json");
-    writeFileSync(
-      configPath,
-      JSON.stringify({ version: 1, hooks: { "my-hook": { enabled: false } } }),
-    );
-
-    // Since setHookEnabled uses getHooksDir() internally, we test the lower-level functions
-    // Read config directly
-    const config = JSON.parse(readFileSync(configPath, "utf-8"));
-    expect(config.hooks["my-hook"].enabled).toBe(false);
-
-    // Simulate enable
-    config.hooks["my-hook"].enabled = true;
-    writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-    const updated = JSON.parse(readFileSync(configPath, "utf-8"));
-    expect(updated.hooks["my-hook"].enabled).toBe(true);
-
-    // Simulate disable
-    updated.hooks["my-hook"].enabled = false;
-    writeFileSync(configPath, JSON.stringify(updated, null, 2));
-
-    const final = JSON.parse(readFileSync(configPath, "utf-8"));
-    expect(final.hooks["my-hook"].enabled).toBe(false);
-  });
-
-  test("removeHook removes config entry", () => {
-    const configPath = join(hooksDir, "config.json");
-    writeFileSync(
-      configPath,
-      JSON.stringify({
-        version: 1,
-        hooks: {
-          "keep-me": { enabled: true },
-          "remove-me": { enabled: false },
-        },
-      }),
-    );
-
-    // Simulate removeHook by manipulating the config directly
-    const config = JSON.parse(readFileSync(configPath, "utf-8"));
-    delete config.hooks["remove-me"];
-    writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-    const updated = JSON.parse(readFileSync(configPath, "utf-8"));
-    expect(updated.hooks["keep-me"]).toBeDefined();
-    expect(updated.hooks["remove-me"]).toBeUndefined();
-  });
-
-  test("install copies directory and creates config entry", () => {
-    // Create a source hook
-    const srcDir = join(hooksDir, "_source");
-    mkdirSync(srcDir, { recursive: true });
-    writeFileSync(
-      join(srcDir, "hook.json"),
-      makeManifest("test-install", ["daemon-start"]),
-    );
-    writeFileSync(join(srcDir, "run.sh"), "#!/bin/sh\necho installed\n", {
-      mode: 0o755,
-    });
-
-    // Simulate install: copy to hooks dir
-    // cpSync and chmodSync imported at top level
-    const targetDir = join(hooksDir, "test-install");
-    cpSync(srcDir, targetDir, { recursive: true });
-    chmodSync(join(targetDir, "run.sh"), 0o755);
-
-    // Verify files exist
-    expect(existsSync(join(targetDir, "hook.json"))).toBe(true);
-    expect(existsSync(join(targetDir, "run.sh"))).toBe(true);
-
-    // Verify hook is discoverable
-    const hooks = discoverHooks(hooksDir);
-    const installed = hooks.find((h) => h.name === "test-install");
-    expect(installed).toBeDefined();
-    expect(installed!.manifest.events).toEqual(["daemon-start"]);
-  });
-
-  test("remove deletes hook directory", () => {
-    installHook("to-remove");
-    expect(existsSync(join(hooksDir, "to-remove"))).toBe(true);
-
-    // Simulate remove
-    rmSync(join(hooksDir, "to-remove"), { recursive: true, force: true });
-
-    expect(existsSync(join(hooksDir, "to-remove"))).toBe(false);
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks.find((h) => h.name === "to-remove")).toBeUndefined();
-  });
-
-  test("list shows version and events for hooks with metadata", () => {
-    installHook("versioned-hook", ["pre-llm-call", "post-llm-call"], {
-      version: "2.3.1",
-    });
-
-    const hooks = discoverHooks(hooksDir);
-    expect(hooks).toHaveLength(1);
-    expect(hooks[0].manifest.version).toBe("2.3.1");
-    expect(hooks[0].manifest.events).toEqual(["pre-llm-call", "post-llm-call"]);
-  });
-});

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

@@ -1,108 +0,0 @@
-import {
-  existsSync,
-  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-config-test-${Date.now()}`);
-process.env.VELLUM_WORKSPACE_DIR = testDir;
-
-import {
-  ensureHookInConfig,
-  isHookEnabled,
-  loadHooksConfig,
-  saveHooksConfig,
-  setHookEnabled,
-} from "../hooks/config.js";
-
-describe("Hooks Config", () => {
-  beforeEach(() => {
-    const hooksDir = join(testDir, "hooks");
-    mkdirSync(hooksDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  test("loadHooksConfig returns defaults when no config file exists", () => {
-    const config = loadHooksConfig();
-    expect(config.version).toBe(1);
-    expect(config.hooks).toEqual({});
-  });
-
-  test("loadHooksConfig reads existing config", () => {
-    const configPath = join(testDir, "hooks", "config.json");
-    writeFileSync(
-      configPath,
-      JSON.stringify({
-        version: 1,
-        hooks: { "my-hook": { enabled: true } },
-      }),
-    );
-
-    const config = loadHooksConfig();
-    expect(config.hooks["my-hook"].enabled).toBe(true);
-  });
-
-  test("loadHooksConfig returns defaults for invalid JSON", () => {
-    const configPath = join(testDir, "hooks", "config.json");
-    writeFileSync(configPath, "NOT VALID JSON {{{");
-
-    const config = loadHooksConfig();
-    expect(config.version).toBe(1);
-    expect(config.hooks).toEqual({});
-  });
-
-  test("loadHooksConfig returns defaults for invalid structure", () => {
-    const configPath = join(testDir, "hooks", "config.json");
-    writeFileSync(configPath, JSON.stringify({ foo: "bar" }));
-
-    const config = loadHooksConfig();
-    expect(config.version).toBe(1);
-    expect(config.hooks).toEqual({});
-  });
-
-  test("saveHooksConfig writes config to disk", () => {
-    const config = { version: 1, hooks: { "test-hook": { enabled: true } } };
-    saveHooksConfig(config);
-
-    const configPath = join(testDir, "hooks", "config.json");
-    expect(existsSync(configPath)).toBe(true);
-    const read = JSON.parse(readFileSync(configPath, "utf-8"));
-    expect(read.hooks["test-hook"].enabled).toBe(true);
-  });
-
-  test("isHookEnabled returns false for unknown hook", () => {
-    expect(isHookEnabled("nonexistent")).toBe(false);
-  });
-
-  test("setHookEnabled enables a hook", () => {
-    setHookEnabled("my-hook", true);
-    expect(isHookEnabled("my-hook")).toBe(true);
-  });
-
-  test("setHookEnabled disables a hook", () => {
-    setHookEnabled("my-hook", true);
-    setHookEnabled("my-hook", false);
-    expect(isHookEnabled("my-hook")).toBe(false);
-  });
-
-  test("ensureHookInConfig adds hook if missing", () => {
-    ensureHookInConfig("new-hook", { enabled: false });
-    const config = loadHooksConfig();
-    expect(config.hooks["new-hook"]).toEqual({ enabled: false });
-  });
-
-  test("ensureHookInConfig does not overwrite existing hook", () => {
-    setHookEnabled("existing", true);
-    ensureHookInConfig("existing", { enabled: false });
-    expect(isHookEnabled("existing")).toBe(true);
-  });
-});