@vellumai/assistant 0.5.5 → 0.5.7

package/src/__tests__/claude-code-skill-regression.test.ts

@@ -1,206 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { describe, expect, mock, spyOn, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mocks — must be set up before importing modules that use them
-// ---------------------------------------------------------------------------
-
-mock.module("@anthropic-ai/claude-agent-sdk", () => ({
-  query: () => ({
-    async *[Symbol.asyncIterator]() {
-      yield {
-        type: "result" as const,
-        session_id: "s",
-        subtype: "success" as const,
-        result: "ok",
-      };
-    },
-  }),
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    services: {
-      inference: {
-        mode: "your-own",
-        provider: "anthropic",
-        model: "claude-opus-4-6",
-      },
-      "image-generation": {
-        mode: "your-own",
-        provider: "gemini",
-        model: "gemini-3.1-flash-image-preview",
-      },
-      "web-search": { mode: "your-own", provider: "inference-provider-native" },
-    },
-  }),
-  loadConfig: () => ({}),
-  loadRawConfig: () => ({}),
-  saveConfig: () => {},
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  syncConfigToLockfile: () => {},
-}));
-
-mock.module("../security/secure-keys.js", () => ({
-  getSecureKeyAsync: async (name: string) =>
-    name === "anthropic" ? "fake-anthropic-key" : null,
-  getProviderKeyAsync: async (provider: string) =>
-    provider === "anthropic" ? "fake-anthropic-key" : undefined,
-}));
-
-// ---------------------------------------------------------------------------
-// Imports (after mocks)
-// ---------------------------------------------------------------------------
-
-import { claudeCodeTool } from "../tools/claude-code/claude-code.js";
-
-// ---------------------------------------------------------------------------
-// Locate the bundled skill directory relative to the test file
-// ---------------------------------------------------------------------------
-
-const SKILL_DIR = path.resolve(
-  import.meta.dirname ?? __dirname,
-  "../config/bundled-skills/claude-code",
-);
-
-const SHARED_DIR = path.resolve(
-  import.meta.dirname ?? __dirname,
-  "../config/bundled-skills/_shared",
-);
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("Claude Code skill migration regression", () => {
-  test("skill script wrapper exports a `run` function", async () => {
-    const wrapperPath = path.join(SKILL_DIR, "tools/claude-code.ts");
-    // The wrapper module must exist and export `run`
-    const mod = await import(wrapperPath);
-    expect(typeof mod.run).toBe("function");
-  });
-
-  test("TOOLS.json manifest lists claude_code as the tool name", () => {
-    const manifestPath = path.join(SKILL_DIR, "TOOLS.json");
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-
-    expect(manifest.version).toBe(1);
-    expect(Array.isArray(manifest.tools)).toBe(true);
-
-    const toolNames = manifest.tools.map((t: { name: string }) => t.name);
-    expect(toolNames).toContain("claude_code");
-  });
-
-  test("TOOLS.json input_schema matches claudeCodeTool.getDefinition()", () => {
-    const manifestPath = path.join(SKILL_DIR, "TOOLS.json");
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-
-    const manifestTool = manifest.tools.find(
-      (t: { name: string }) => t.name === "claude_code",
-    );
-    expect(manifestTool).toBeDefined();
-
-    const runtimeDef = claudeCodeTool.getDefinition();
-
-    // The input_schema declared in the static manifest must match the
-    // runtime definition. Drift here would mean the model sees a different
-    // schema than the executor actually supports.
-    expect(manifestTool.input_schema).toEqual(runtimeDef.input_schema);
-  });
-
-  test("TOOLS.json description matches claudeCodeTool.getDefinition()", () => {
-    const manifestPath = path.join(SKILL_DIR, "TOOLS.json");
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-
-    const manifestTool = manifest.tools.find(
-      (t: { name: string }) => t.name === "claude_code",
-    );
-    expect(manifestTool).toBeDefined();
-
-    const runtimeDef = claudeCodeTool.getDefinition();
-
-    // Description parity guards against a manifest edit that diverges from
-    // the canonical tool description.
-    expect(manifestTool.description).toBe(runtimeDef.description);
-  });
-
-  test("wrapper run() delegates to claudeCodeTool.execute()", async () => {
-    // Verifies the wrapper is not a stale stub but actually calls through
-    // to the canonical execute method with the exact input and context.
-    const spy = spyOn(claudeCodeTool, "execute");
-
-    const wrapperPath = path.join(SKILL_DIR, "tools/claude-code.ts");
-    const mod = await import(wrapperPath);
-
-    const input = { prompt: "hello" };
-    const ctx = {
-      conversationId: "test",
-      workingDir: "/tmp",
-      onOutput: () => {},
-    };
-
-    const result = await mod.run(input, ctx);
-    expect(result.isError).toBeFalsy();
-
-    // The wrapper must delegate to the canonical execute method
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy).toHaveBeenCalledWith(input, ctx);
-
-    spy.mockRestore();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Bundled skill shared guidance — CES tools instead of token-reveal
-// ---------------------------------------------------------------------------
-
-describe("CLI_RETRIEVAL_PATTERN.md CES guidance", () => {
-  const patternPath = path.join(SHARED_DIR, "CLI_RETRIEVAL_PATTERN.md");
-  const content = fs.readFileSync(patternPath, "utf-8");
-
-  test("teaches handle discovery via assistant credentials list", () => {
-    expect(content).toContain("assistant credentials list");
-  });
-
-  test("teaches handle discovery via assistant oauth connections list", () => {
-    expect(content).toContain("assistant oauth connections list");
-  });
-
-  test("teaches make_authenticated_request CES tool", () => {
-    expect(content).toContain("make_authenticated_request");
-  });
-
-  test("teaches run_authenticated_command CES tool", () => {
-    expect(content).toContain("run_authenticated_command");
-  });
-
-  test("warns that host_bash is outside CES secrecy boundary", () => {
-    expect(content).toContain("outside the CES secrecy boundary");
-  });
-
-  // -- Deprecated patterns must NOT appear --
-
-  test("does not teach proxied bash with credential_ids", () => {
-    expect(content).not.toContain("credential_ids");
-    expect(content).not.toContain("network_mode: proxied");
-  });
-
-  test("does not teach oauth connections token for raw token extraction", () => {
-    expect(content).not.toContain("oauth connections token");
-  });
-});

package/src/__tests__/claude-code-tool-profiles.test.ts

@@ -1,99 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mock the Agent SDK — prevents real subprocess spawning
-// ---------------------------------------------------------------------------
-const queryMock = mock(() => {
-  // Returns an async iterable that yields a success result
-  return {
-    async *[Symbol.asyncIterator]() {
-      yield {
-        type: "result" as const,
-        session_id: "test-session",
-        subtype: "success" as const,
-        result: "Done.",
-      };
-    },
-  };
-});
-
-mock.module("@anthropic-ai/claude-agent-sdk", () => ({
-  query: queryMock,
-}));
-
-// Mock logger
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-// Mock config
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-  }),
-}));
-
-// Mock secure-keys — provide a fake Anthropic API key
-mock.module("../security/secure-keys.js", () => ({
-  getSecureKeyAsync: async (name: string) =>
-    name === "anthropic" ? "fake-anthropic-key" : null,
-  getProviderKeyAsync: async (provider: string) =>
-    provider === "anthropic" ? "fake-anthropic-key" : undefined,
-}));
-
-import { claudeCodeTool } from "../tools/claude-code/claude-code.js";
-import type { ToolContext } from "../tools/types.js";
-
-function makeContext(overrides?: Partial<ToolContext>): ToolContext {
-  return {
-    conversationId: "test-session",
-    workingDir: "/tmp/test",
-    trustClass: "guardian",
-    onOutput: () => {},
-    ...overrides,
-  } as ToolContext;
-}
-
-describe("claude_code tool profile support", () => {
-  beforeEach(() => {
-    queryMock.mockClear();
-  });
-
-  test("getDefinition includes profile parameter", () => {
-    const def = claudeCodeTool.getDefinition();
-    const props = (def.input_schema as Record<string, unknown>)
-      .properties as Record<string, unknown>;
-    expect(props.profile).toBeDefined();
-  });
-
-  test("rejects invalid profile", async () => {
-    const result = await claudeCodeTool.execute(
-      { prompt: "test", profile: "hacker" },
-      makeContext(),
-    );
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("Invalid profile");
-  });
-
-  test("accepts valid profiles without error", async () => {
-    for (const profile of ["general", "researcher", "coder", "reviewer"]) {
-      queryMock.mockClear();
-      const result = await claudeCodeTool.execute(
-        { prompt: "test", profile },
-        makeContext(),
-      );
-      expect(result.isError).toBeFalsy();
-    }
-  });
-
-  test("omitted profile defaults to general", async () => {
-    const result = await claudeCodeTool.execute(
-      { prompt: "test" },
-      makeContext(),
-    );
-    expect(result.isError).toBeFalsy();
-  });
-});

package/src/__tests__/conversation-memory-dirty-tail.test.ts

@@ -1,150 +0,0 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
-
-const testDir = mkdtempSync(join(tmpdir(), "conv-dirty-tail-test-"));
-
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-import {
-  addMessage,
-  createConversation,
-  getConversation,
-  getMessages,
-  markConversationMemoryDirty,
-} from "../memory/conversation-crud.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
-
-initializeDb();
-
-afterAll(() => {
-  resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
-});
-
-describe("markConversationMemoryDirty", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run(`DELETE FROM messages`);
-    db.run(`DELETE FROM conversations`);
-  });
-
-  test("first message marks the conversation dirty with its message ID", async () => {
-    const conv = createConversation("test");
-    const msg = await addMessage(conv.id, "user", "hello world", undefined, {
-      skipIndexing: true,
-    });
-
-    const updated = getConversation(conv.id);
-    expect(updated).not.toBeNull();
-    expect(updated!.memoryDirtyTailSinceMessageId).toBe(msg.id);
-  });
-
-  test("repeated messages preserve the original dirty boundary", async () => {
-    const conv = createConversation("test");
-    const msg1 = await addMessage(conv.id, "user", "first message", undefined, {
-      skipIndexing: true,
-    });
-    const msg2 = await addMessage(
-      conv.id,
-      "assistant",
-      "second message",
-      undefined,
-      { skipIndexing: true },
-    );
-
-    const updated = getConversation(conv.id);
-    expect(updated).not.toBeNull();
-    // The dirty tail should still point to msg1, not msg2.
-    expect(updated!.memoryDirtyTailSinceMessageId).toBe(msg1.id);
-    // msg2 should still be persisted normally.
-    expect(msg2.id).not.toBe(msg1.id);
-  });
-
-  test("markConversationMemoryDirty is a no-op when already dirty", () => {
-    const conv = createConversation("test");
-    const firstMessageId = "first-msg-id";
-    const secondMessageId = "second-msg-id";
-
-    markConversationMemoryDirty(conv.id, firstMessageId);
-    const after1 = getConversation(conv.id);
-    expect(after1!.memoryDirtyTailSinceMessageId).toBe(firstMessageId);
-
-    markConversationMemoryDirty(conv.id, secondMessageId);
-    const after2 = getConversation(conv.id);
-    // Still points to the first message — boundary preserved.
-    expect(after2!.memoryDirtyTailSinceMessageId).toBe(firstMessageId);
-  });
-
-  test("message ordering and persistence semantics are unchanged", async () => {
-    const conv = createConversation("test");
-    const msg1 = await addMessage(conv.id, "user", "question", undefined, {
-      skipIndexing: true,
-    });
-    const msg2 = await addMessage(conv.id, "assistant", "answer", undefined, {
-      skipIndexing: true,
-    });
-    const msg3 = await addMessage(conv.id, "user", "follow-up", undefined, {
-      skipIndexing: true,
-    });
-
-    const allMessages = getMessages(conv.id);
-    expect(allMessages).toHaveLength(3);
-    // Messages are ordered by createdAt ascending.
-    expect(allMessages[0].id).toBe(msg1.id);
-    expect(allMessages[1].id).toBe(msg2.id);
-    expect(allMessages[2].id).toBe(msg3.id);
-    expect(allMessages[0].content).toBe("question");
-    expect(allMessages[1].content).toBe("answer");
-    expect(allMessages[2].content).toBe("follow-up");
-    // createdAt is monotonically increasing.
-    expect(allMessages[1].createdAt).toBeGreaterThan(allMessages[0].createdAt);
-    expect(allMessages[2].createdAt).toBeGreaterThan(allMessages[1].createdAt);
-  });
-
-  test("every persisted message marks the conversation dirty", async () => {
-    const conv = createConversation("test");
-
-    // Before any messages, the conversation is not dirty.
-    const before = getConversation(conv.id);
-    expect(before!.memoryDirtyTailSinceMessageId).toBeNull();
-
-    // After the first message, it becomes dirty.
-    const msg1 = await addMessage(conv.id, "user", "msg1", undefined, {
-      skipIndexing: true,
-    });
-    const after1 = getConversation(conv.id);
-    expect(after1!.memoryDirtyTailSinceMessageId).toBe(msg1.id);
-
-    // After subsequent messages, the dirty boundary stays on msg1.
-    await addMessage(conv.id, "assistant", "msg2", undefined, {
-      skipIndexing: true,
-    });
-    await addMessage(conv.id, "user", "msg3", undefined, {
-      skipIndexing: true,
-    });
-    const afterAll = getConversation(conv.id);
-    expect(afterAll!.memoryDirtyTailSinceMessageId).toBe(msg1.id);
-  });
-});