@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/__tests__/helpers/set-workspace-mcp.ts

@@ -1,11 +0,0 @@
-/**
- * Seed `$VELLUM_WORKSPACE_DIR/mcp.json` for tests that go through the
- * real workspace MCP loader.
- */
-
-import type { McpConfig } from "../../config/schemas/mcp.js";
-import { saveWorkspaceMcpConfig } from "../../mcp/workspace-mcp-config.js";
-
-export function setWorkspaceMcp(servers: McpConfig["servers"]): void {
-  saveWorkspaceMcpConfig({ servers });
-}

package/src/__tests__/message-deleted-hook-dispatch.test.ts

@@ -1,119 +0,0 @@
-/**
- * The `message-deleted` hook is dispatched by every primitive that removes
- * individual message rows, carrying each row's `(createdAt, id)`, so a plugin
- * keeping a cursor on a row learns where it sat once the row is gone.
- * DB-backed: exercises the real delete primitives against the test database.
- */
-import { beforeEach, describe, expect, test } from "bun:test";
-
-import { registerPluginHooks } from "../hooks/registry.js";
-import type { MessageDeletedContext } from "../hooks/types.js";
-import {
-  addMessage,
-  deleteLastExchange,
-  deleteMessageById,
-  getMessages,
-} from "../persistence/conversation-crud.js";
-import { getDb } from "../persistence/db-connection.js";
-import { initializeDb } from "../persistence/db-init.js";
-import { conversations, messages } from "../persistence/schema/index.js";
-import type { PluginHooks } from "../plugins/types.js";
-
-await initializeDb();
-
-const CONV_ID = "conv-message-deleted-hook";
-
-const received: Array<{
-  conversationId: string;
-  messageId: string;
-  createdAt: number;
-}> = [];
-registerPluginHooks("test-message-deleted-spy", {
-  "message-deleted": async (ctx: MessageDeletedContext) => {
-    received.push({
-      conversationId: ctx.conversationId,
-      messageId: ctx.messageId,
-      createdAt: ctx.createdAt,
-    });
-  },
-} as PluginHooks);
-
-/** Poll until the fire-and-forget hook chain has delivered `count` calls. */
-async function waitForCalls(count: number): Promise<void> {
-  const deadline = Date.now() + 2_000;
-  while (received.length < count && Date.now() < deadline) {
-    await Bun.sleep(10);
-  }
-}
-
-const text = (t: string) => JSON.stringify([{ type: "text", text: t }]);
-
-beforeEach(() => {
-  received.length = 0;
-  getDb().delete(messages).run();
-  getDb().delete(conversations).run();
-  const now = Date.now();
-  getDb()
-    .insert(conversations)
-    .values({
-      id: CONV_ID,
-      title: "message-deleted hook",
-      createdAt: now,
-      updatedAt: now,
-      source: "test",
-      conversationType: "standard",
-    })
-    .run();
-});
-
-describe("message-deleted hook dispatch", () => {
-  test("deleteMessageById dispatches once with the row's position", async () => {
-    await addMessage(CONV_ID, "user", text("hello"));
-    const reply = await addMessage(CONV_ID, "assistant", text("hi"));
-    const replyCreatedAt = getMessages(CONV_ID).find(
-      (m) => m.id === reply.id,
-    )!.createdAt;
-
-    deleteMessageById(reply.id);
-    await waitForCalls(1);
-
-    expect(received).toEqual([
-      {
-        conversationId: CONV_ID,
-        messageId: reply.id,
-        createdAt: replyCreatedAt,
-      },
-    ]);
-  });
-
-  test("deleteLastExchange dispatches for every row of the undone tail", async () => {
-    await addMessage(CONV_ID, "user", text("first"));
-    await addMessage(CONV_ID, "assistant", text("one"));
-    const user2 = await addMessage(CONV_ID, "user", text("second"));
-    const reply2 = await addMessage(CONV_ID, "assistant", text("two"));
-    const byId = new Map(getMessages(CONV_ID).map((m) => [m.id, m.createdAt]));
-
-    expect(deleteLastExchange(CONV_ID)).toBe(2);
-    await waitForCalls(2);
-
-    expect([...received].sort((a, b) => a.createdAt - b.createdAt)).toEqual([
-      {
-        conversationId: CONV_ID,
-        messageId: user2.id,
-        createdAt: byId.get(user2.id)!,
-      },
-      {
-        conversationId: CONV_ID,
-        messageId: reply2.id,
-        createdAt: byId.get(reply2.id)!,
-      },
-    ]);
-  });
-
-  test("a delete of a missing row dispatches nothing", async () => {
-    deleteMessageById("no-such-row");
-    await Bun.sleep(50);
-
-    expect(received).toEqual([]);
-  });
-});

package/src/__tests__/resolve-app.test.ts

@@ -1,135 +0,0 @@
-/**
- * Tests for resolving an app query by name, slug, or id.
- */
-
-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 { createApp } from "../apps/app-store.js";
-import { resolveAppQuery } from "../apps/resolve-app.js";
-import { getWorkspacePluginsDir } from "../util/platform.js";
-
-let workspaceDir: string;
-let previousWorkspaceDir: string | undefined;
-
-function freshWorkspace(): string {
-  return join(
-    tmpdir(),
-    `vellum-resolve-app-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-  );
-}
-
-function installPlugin(name: string): string {
-  const pluginDir = join(getWorkspacePluginsDir(), name);
-  mkdirSync(pluginDir, { recursive: true });
-  writeFileSync(
-    join(pluginDir, "package.json"),
-    JSON.stringify({ name, version: "1.0.0" }),
-  );
-  return pluginDir;
-}
-
-function bundleApp(pluginDir: string, app: string): void {
-  const appDir = join(pluginDir, "apps", app);
-  mkdirSync(appDir, { recursive: true });
-  writeFileSync(join(appDir, "index.html"), "<h1>Plugin app</h1>");
-}
-
-beforeEach(() => {
-  previousWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
-  workspaceDir = freshWorkspace();
-  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
-});
-
-afterEach(() => {
-  rmSync(workspaceDir, { recursive: true, force: true });
-  if (previousWorkspaceDir === undefined) {
-    delete process.env.VELLUM_WORKSPACE_DIR;
-  } else {
-    process.env.VELLUM_WORKSPACE_DIR = previousWorkspaceDir;
-  }
-});
-
-describe("resolveAppQuery", () => {
-  test("resolves a workspace app by display name, slug, and id", () => {
-    const created = createApp({
-      name: "Budget",
-      schemaJson: "{}",
-      htmlDefinition: "<h1>Budget</h1>",
-    });
-
-    const byName = resolveAppQuery("Budget");
-    expect(byName.ok).toBe(true);
-    if (byName.ok) {
-      expect(byName.app.id).toBe(created.id);
-    }
-
-    const byNameCase = resolveAppQuery("budget");
-    expect(byNameCase.ok).toBe(true);
-    if (byNameCase.ok) {
-      expect(byNameCase.app.id).toBe(created.id);
-    }
-
-    const slug = created.dirName ?? "";
-    expect(slug.length).toBeGreaterThan(0);
-    const bySlug = resolveAppQuery(slug);
-    expect(bySlug.ok).toBe(true);
-    if (bySlug.ok) {
-      expect(bySlug.app.id).toBe(created.id);
-    }
-
-    const byId = resolveAppQuery(created.id);
-    expect(byId.ok).toBe(true);
-    if (byId.ok) {
-      expect(byId.app.id).toBe(created.id);
-    }
-  });
-
-  test("returns not_found for an unknown name", () => {
-    const result = resolveAppQuery("missing");
-    expect(result).toEqual({
-      ok: false,
-      reason: "not_found",
-      query: "missing",
-    });
-  });
-
-  test("returns ambiguous when two apps share a display name", () => {
-    const first = createApp({
-      name: "Notes",
-      schemaJson: "{}",
-      htmlDefinition: "<h1>One</h1>",
-    });
-    const second = createApp({
-      name: "Notes",
-      schemaJson: "{}",
-      htmlDefinition: "<h1>Two</h1>",
-    });
-
-    const result = resolveAppQuery("Notes");
-    expect(result.ok).toBe(false);
-    if (!result.ok && result.reason === "ambiguous") {
-      const ids = result.matches.map((m) => m.id).sort();
-      expect(ids).toEqual([first.id, second.id].sort());
-    } else {
-      throw new Error("expected ambiguous resolution");
-    }
-  });
-
-  test("resolves a plugin app by directory name", () => {
-    const pluginDir = installPlugin("charts");
-    bundleApp(pluginDir, "viewer");
-
-    const result = resolveAppQuery("viewer");
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.app.origin).toEqual({
-        kind: "plugin",
-        pluginName: "charts",
-      });
-      expect(result.app.id).toBe("plugins~charts~viewer");
-    }
-  });
-});

package/src/__tests__/source-fingerprint.test.ts

@@ -1,184 +0,0 @@
-/**
- * Tests for app source fingerprinting: walk exclusions, comparison, inspect
- * statuses, and the compile-time sidecar format.
- */
-
-import {
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  symlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import {
-  compareAppSourceFingerprint,
-  computeAppSourceFingerprint,
-  inspectAppSource,
-  parseAppSourceFingerprint,
-  SOURCE_FINGERPRINT_FILENAME,
-  writeAppSourceFingerprint,
-} from "../apps/source-fingerprint.js";
-
-let root: string;
-
-beforeEach(() => {
-  root = mkdtempSync(join(tmpdir(), "app-source-fingerprint-"));
-});
-
-afterEach(() => {
-  rmSync(root, { recursive: true, force: true });
-});
-
-function write(rel: string, contents: string): void {
-  const abs = join(root, rel);
-  mkdirSync(join(abs, ".."), { recursive: true });
-  writeFileSync(abs, contents);
-}
-
-describe("computeAppSourceFingerprint", () => {
-  test("digests source files with POSIX-relative keys", () => {
-    write("src/main.tsx", "export const x = 1;");
-    write("src/index.html", "<html></html>");
-
-    const fp = computeAppSourceFingerprint(root);
-
-    expect(Object.keys(fp.files).sort()).toEqual([
-      "src/index.html",
-      "src/main.tsx",
-    ]);
-    expect(fp.algorithm).toBe("sha256");
-    expect(fp.files["src/main.tsx"]).toMatch(/^[0-9a-f]{64}$/);
-  });
-
-  test("skips dist, records, node_modules, and .git", () => {
-    write("src/main.tsx", "src");
-    write("dist/main.js", "compiled");
-    write("records/rec-1.json", "{}");
-    write("node_modules/pkg/index.js", "dep");
-    write("src/node_modules/nested/index.js", "nested");
-    write(".git/HEAD", "ref");
-    write("src/.git/config", "nope");
-
-    const fp = computeAppSourceFingerprint(root);
-
-    expect(Object.keys(fp.files)).toEqual(["src/main.tsx"]);
-  });
-
-  test("skips symlinks", () => {
-    write("src/real.tsx", "hello");
-    mkdirSync(join(root, "src"), { recursive: true });
-    symlinkSync(join(root, "src/real.tsx"), join(root, "src/link.tsx"));
-
-    const fp = computeAppSourceFingerprint(root);
-
-    expect(Object.keys(fp.files)).toEqual(["src/real.tsx"]);
-  });
-});
-
-describe("compareAppSourceFingerprint", () => {
-  test("reports modified, added, and removed paths", () => {
-    write("src/main.tsx", "one");
-    write("src/keep.tsx", "keep");
-    const baseline = computeAppSourceFingerprint(root);
-
-    write("src/main.tsx", "two");
-    write("src/new.tsx", "new");
-    rmSync(join(root, "src/keep.tsx"));
-
-    const diff = compareAppSourceFingerprint(root, baseline);
-    expect(diff.clean).toBe(false);
-    expect(diff.modified).toEqual(["src/main.tsx"]);
-    expect(diff.added).toEqual(["src/new.tsx"]);
-    expect(diff.removed).toEqual(["src/keep.tsx"]);
-  });
-
-  test("is clean when source matches the baseline", () => {
-    write("src/main.tsx", "same");
-    const baseline = computeAppSourceFingerprint(root);
-    const diff = compareAppSourceFingerprint(root, baseline);
-    expect(diff.clean).toBe(true);
-    expect(diff.modified).toEqual([]);
-    expect(diff.added).toEqual([]);
-    expect(diff.removed).toEqual([]);
-  });
-});
-
-describe("inspectAppSource", () => {
-  test("reports never_compiled when dist index is missing even if a fingerprint exists", () => {
-    write("src/main.tsx", "src");
-    mkdirSync(join(root, "dist"), { recursive: true });
-    writeAppSourceFingerprint(root, join(root, "dist"));
-
-    const result = inspectAppSource(root);
-    expect(result.status).toBe("never_compiled");
-  });
-
-  test("reports unknown_baseline when dist exists without a fingerprint", () => {
-    write("src/main.tsx", "src");
-    write("dist/index.html", "<html></html>");
-    const result = inspectAppSource(root);
-    expect(result.status).toBe("unknown_baseline");
-  });
-
-  test("reports clean after writing a fingerprint that matches source", () => {
-    write("src/main.tsx", "src");
-    mkdirSync(join(root, "dist"), { recursive: true });
-    writeFileSync(join(root, "dist", "index.html"), "<html></html>");
-    writeAppSourceFingerprint(root, join(root, "dist"));
-
-    const result = inspectAppSource(root);
-    expect(result.status).toBe("clean");
-    expect(result.compiledAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-  });
-
-  test("reports stale after a source edit", () => {
-    write("src/main.tsx", "before");
-    mkdirSync(join(root, "dist"), { recursive: true });
-    writeFileSync(join(root, "dist", "index.html"), "<html></html>");
-    writeAppSourceFingerprint(root, join(root, "dist"));
-    write("src/main.tsx", "after");
-
-    const result = inspectAppSource(root);
-    expect(result.status).toBe("stale");
-    expect(result.modified).toEqual(["src/main.tsx"]);
-  });
-});
-
-describe("parseAppSourceFingerprint", () => {
-  test("accepts a compile sidecar with compiledAt", () => {
-    const parsed = parseAppSourceFingerprint({
-      algorithm: "sha256",
-      compiledAt: "2026-09-09T00:00:00.000Z",
-      files: { "src/main.tsx": "abc" },
-    });
-    expect(parsed).toEqual({
-      algorithm: "sha256",
-      compiledAt: "2026-09-09T00:00:00.000Z",
-      files: { "src/main.tsx": "abc" },
-    });
-  });
-
-  test("returns null for an invalid sidecar", () => {
-    expect(parseAppSourceFingerprint({ algorithm: "md5", files: {} })).toBe(
-      null,
-    );
-    expect(parseAppSourceFingerprint(null)).toBeNull();
-  });
-
-  test("writeAppSourceFingerprint records a sidecar the parser accepts", () => {
-    write("src/main.tsx", "src");
-    mkdirSync(join(root, "dist"), { recursive: true });
-    writeAppSourceFingerprint(root, join(root, "dist"));
-    const raw = JSON.parse(
-      readFileSync(join(root, "dist", SOURCE_FINGERPRINT_FILENAME), "utf-8"),
-    );
-    expect(parseAppSourceFingerprint(raw)?.files["src/main.tsx"]).toMatch(
-      /^[0-9a-f]{64}$/,
-    );
-  });
-});