@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/document-find-replace.test.ts

@@ -0,0 +1,501 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getDocumentById } from "../documents/document-store.js";
+import { getSqlite, resetDb } from "../memory/db-connection.js";
+import {
+  executeDocumentFind,
+  executeDocumentReplaceText,
+} from "../tools/document/document-tool.js";
+import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
+
+function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
+  return {
+    workingDir: "/tmp/project",
+    conversationId: "conv-current",
+    trustClass: "trusted_contact",
+    executionChannel: "slack",
+    ...overrides,
+  };
+}
+
+function parseResult<T>(result: ToolExecutionResult): T {
+  return JSON.parse(result.content) as T;
+}
+
+function bootstrapDocumentTables(): void {
+  resetDb();
+  const raw = getSqlite();
+  raw.exec(/*sql*/ `
+    DROP TABLE IF EXISTS document_conversations;
+    DROP TABLE IF EXISTS documents;
+    DROP TABLE IF EXISTS conversations;
+
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)
+    );
+
+    CREATE TABLE documents (
+      surface_id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      word_count INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE document_conversations (
+      surface_id TEXT NOT NULL,
+      conversation_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (surface_id, conversation_id),
+      FOREIGN KEY (surface_id) REFERENCES documents(surface_id) ON DELETE CASCADE
+    );
+  `);
+}
+
+function seedDocument(params: {
+  surfaceId: string;
+  conversationId: string;
+  title: string;
+  content: string;
+  updatedAt: number;
+}): void {
+  const raw = getSqlite();
+  raw
+    .query(`INSERT OR IGNORE INTO conversations (id, created_at) VALUES (?, ?)`)
+    .run(params.conversationId, params.updatedAt);
+  raw
+    .query(
+      `INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      params.surfaceId,
+      params.conversationId,
+      params.title,
+      params.content,
+      params.content.split(/\s+/).filter(Boolean).length,
+      params.updatedAt,
+      params.updatedAt,
+    );
+  raw
+    .query(
+      `INSERT OR IGNORE INTO document_conversations (surface_id, conversation_id, created_at) VALUES (?, ?, ?)`,
+    )
+    .run(params.surfaceId, params.conversationId, params.updatedAt);
+}
+
+// ---------------------------------------------------------------------------
+// document_find tests
+// ---------------------------------------------------------------------------
+
+interface FindResultBody {
+  success: boolean;
+  surface_id?: string;
+  query?: string;
+  total_matches?: number;
+  matches?: Array<{
+    line_number: number;
+    line_content: string;
+    match_start: number;
+    match_end: number;
+    match_text: string;
+  }>;
+  error?: string;
+}
+
+const MULTILINE_CONTENT = [
+  "Hello World",
+  "This is line two with some numbers 42 and 100",
+  "hello again on line three",
+  "HELLO UPPERCASE LINE FOUR",
+  "Final line with special chars: foo-bar_baz",
+].join("\n");
+
+describe("document_find", () => {
+  beforeEach(() => {
+    bootstrapDocumentTables();
+    seedDocument({
+      surfaceId: "doc-find-test",
+      conversationId: "conv-current",
+      title: "Find Test Doc",
+      content: MULTILINE_CONTENT,
+      updatedAt: 1000,
+    });
+    seedDocument({
+      surfaceId: "doc-other-conv",
+      conversationId: "conv-other",
+      title: "Other Conv Doc",
+      content: "secret content here",
+      updatedAt: 2000,
+    });
+  });
+
+  test("literal search finds exact matches with correct line numbers", () => {
+    const result = executeDocumentFind(
+      { surface_id: "doc-find-test", query: "Hello" },
+      makeContext(),
+    );
+    const body = parseResult<FindResultBody>(result);
+
+    expect(body.success).toBe(true);
+    expect(body.total_matches).toBe(3);
+    expect(body.matches![0].line_number).toBe(1);
+    expect(body.matches![0].match_text).toBe("Hello");
+    expect(body.matches![1].line_number).toBe(3);
+    expect(body.matches![1].match_text).toBe("hello");
+    expect(body.matches![2].line_number).toBe(4);
+    expect(body.matches![2].match_text).toBe("HELLO");
+  });
+
+  test("case-insensitive search (default) matches regardless of case", () => {
+    const result = executeDocumentFind(
+      { surface_id: "doc-find-test", query: "hello" },
+      makeContext(),
+    );
+    const body = parseResult<FindResultBody>(result);
+
+    expect(body.success).toBe(true);
+    expect(body.total_matches).toBe(3);
+    const lineNumbers = body.matches!.map((m) => m.line_number);
+    expect(lineNumbers).toEqual([1, 3, 4]);
+  });
+
+  test("case-sensitive search only matches exact case", () => {
+    const result = executeDocumentFind(
+      { surface_id: "doc-find-test", query: "Hello", case_sensitive: true },
+      makeContext(),
+    );
+    const body = parseResult<FindResultBody>(result);
+
+    expect(body.success).toBe(true);
+    expect(body.total_matches).toBe(1);
+    expect(body.matches![0].line_number).toBe(1);
+    expect(body.matches![0].match_text).toBe("Hello");
+  });
+
+  test("regex search works", () => {
+    const result = executeDocumentFind(
+      { surface_id: "doc-find-test", query: "\\d+", regex: true },
+      makeContext(),
+    );
+    const body = parseResult<FindResultBody>(result);
+
+    expect(body.success).toBe(true);
+    expect(body.total_matches).toBe(2);
+    expect(body.matches![0].match_text).toBe("42");
+    expect(body.matches![0].line_number).toBe(2);
+    expect(body.matches![1].match_text).toBe("100");
+    expect(body.matches![1].line_number).toBe(2);
+  });
+
+  test("invalid regex returns error gracefully", () => {
+    const result = executeDocumentFind(
+      { surface_id: "doc-find-test", query: "[invalid", regex: true },
+      makeContext(),
+    );
+    const body = parseResult<FindResultBody>(result);
+
+    expect(result.isError).toBe(true);
+    expect(body.success).toBe(false);
+    expect(body.error).toMatch(/Invalid regex/);
+  });
+
+  test("no matches returns success with empty array", () => {
+    const result = executeDocumentFind(
+      { surface_id: "doc-find-test", query: "nonexistent-text-xyz" },
+      makeContext(),
+    );
+    const body = parseResult<FindResultBody>(result);
+
+    expect(body.success).toBe(true);
+    expect(body.total_matches).toBe(0);
+    expect(body.matches).toEqual([]);
+  });
+
+  test("access control blocks non-guardian from searching documents outside their conversation", () => {
+    const result = executeDocumentFind(
+      { surface_id: "doc-other-conv", query: "secret" },
+      makeContext({
+        trustClass: "trusted_contact",
+        executionChannel: "slack",
+        conversationId: "conv-current",
+      }),
+    );
+
+    expect(result.isError).toBe(true);
+    const body = parseResult<FindResultBody>(result);
+    expect(body.error).toBe("Document not found");
+  });
+
+  test("results are capped at 50 matches", () => {
+    const lines = Array.from({ length: 100 }, (_, i) => `match line ${i}`);
+    seedDocument({
+      surfaceId: "doc-many-matches",
+      conversationId: "conv-current",
+      title: "Many Matches",
+      content: lines.join("\n"),
+      updatedAt: 3000,
+    });
+
+    const result = executeDocumentFind(
+      { surface_id: "doc-many-matches", query: "match" },
+      makeContext(),
+    );
+    const body = parseResult<FindResultBody>(result);
+
+    expect(body.success).toBe(true);
+    expect(body.total_matches).toBe(100);
+    expect(body.matches!.length).toBe(50);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// document_replace_text tests
+// ---------------------------------------------------------------------------
+
+describe("document_replace_text", () => {
+  beforeEach(() => {
+    bootstrapDocumentTables();
+    seedDocument({
+      surfaceId: "doc-replace",
+      conversationId: "conv-current",
+      title: "Replace Test",
+      content: "foo bar foo baz foo",
+      updatedAt: 1000,
+    });
+    seedDocument({
+      surfaceId: "doc-other",
+      conversationId: "conv-other",
+      title: "Other Doc",
+      content: "other content",
+      updatedAt: 2000,
+    });
+  });
+
+  test("literal replace replaces all occurrences", () => {
+    const result = executeDocumentReplaceText(
+      { surface_id: "doc-replace", find: "foo", replace: "qux" },
+      makeContext({ sendToClient: () => {} }),
+    );
+    const body = parseResult<{
+      success: boolean;
+      replacements_made: number;
+      content_changed: boolean;
+    }>(result);
+    expect(body.success).toBe(true);
+    expect(body.replacements_made).toBe(3);
+    expect(body.content_changed).toBe(true);
+    expect(getDocumentById("doc-replace")?.content).toBe("qux bar qux baz qux");
+  });
+
+  test("case-insensitive literal replace (default)", () => {
+    seedDocument({
+      surfaceId: "doc-case",
+      conversationId: "conv-current",
+      title: "Case Test",
+      content: "Foo FOO foo",
+      updatedAt: 3000,
+    });
+    const result = executeDocumentReplaceText(
+      { surface_id: "doc-case", find: "foo", replace: "x" },
+      makeContext({ sendToClient: () => {} }),
+    );
+    const body = parseResult<{
+      success: boolean;
+      replacements_made: number;
+    }>(result);
+    expect(body.success).toBe(true);
+    expect(body.replacements_made).toBe(3);
+    expect(getDocumentById("doc-case")?.content).toBe("x x x");
+  });
+
+  test("case-sensitive literal replace", () => {
+    seedDocument({
+      surfaceId: "doc-case-sensitive",
+      conversationId: "conv-current",
+      title: "Case Sensitive Test",
+      content: "Foo FOO foo",
+      updatedAt: 3000,
+    });
+    const result = executeDocumentReplaceText(
+      {
+        surface_id: "doc-case-sensitive",
+        find: "foo",
+        replace: "x",
+        case_sensitive: true,
+      },
+      makeContext({ sendToClient: () => {} }),
+    );
+    const body = parseResult<{
+      success: boolean;
+      replacements_made: number;
+    }>(result);
+    expect(body.success).toBe(true);
+    expect(body.replacements_made).toBe(1);
+    expect(getDocumentById("doc-case-sensitive")?.content).toBe("Foo FOO x");
+  });
+
+  test("regex replace with backreferences", () => {
+    seedDocument({
+      surfaceId: "doc-regex",
+      conversationId: "conv-current",
+      title: "Regex Test",
+      content: "user1@example user2@test",
+      updatedAt: 3000,
+    });
+    const result = executeDocumentReplaceText(
+      {
+        surface_id: "doc-regex",
+        find: "(\\w+)@(\\w+)",
+        replace: "$2/$1",
+        regex: true,
+        case_sensitive: true,
+      },
+      makeContext({ sendToClient: () => {} }),
+    );
+    const body = parseResult<{
+      success: boolean;
+      replacements_made: number;
+    }>(result);
+    expect(body.success).toBe(true);
+    expect(body.replacements_made).toBe(2);
+    expect(getDocumentById("doc-regex")?.content).toBe(
+      "example/user1 test/user2",
+    );
+  });
+
+  test("invalid regex returns clean error", () => {
+    const result = executeDocumentReplaceText(
+      {
+        surface_id: "doc-replace",
+        find: "[invalid",
+        replace: "x",
+        regex: true,
+      },
+      makeContext({ sendToClient: () => {} }),
+    );
+    const body = parseResult<{ success: boolean; error: string }>(result);
+    expect(body.success).toBe(false);
+    expect(body.error).toMatch(/Invalid regex/);
+    expect(result.isError).toBe(true);
+  });
+
+  test("max_replacements limits substitutions", () => {
+    const result = executeDocumentReplaceText(
+      {
+        surface_id: "doc-replace",
+        find: "foo",
+        replace: "qux",
+        max_replacements: 1,
+      },
+      makeContext({ sendToClient: () => {} }),
+    );
+    const body = parseResult<{
+      success: boolean;
+      replacements_made: number;
+      content_changed: boolean;
+    }>(result);
+    expect(body.success).toBe(true);
+    expect(body.replacements_made).toBe(1);
+    expect(body.content_changed).toBe(true);
+    expect(getDocumentById("doc-replace")?.content).toBe("qux bar foo baz foo");
+  });
+
+  test("max_replacements with regex backreferences replaces correctly", () => {
+    seedDocument({
+      surfaceId: "doc-regex-limit",
+      conversationId: "conv-current",
+      title: "Regex Limit Test",
+      content: "a@b c@d e@f",
+      updatedAt: 3000,
+    });
+    const result = executeDocumentReplaceText(
+      {
+        surface_id: "doc-regex-limit",
+        find: "(\\w+)@(\\w+)",
+        replace: "$2/$1",
+        regex: true,
+        case_sensitive: true,
+        max_replacements: 2,
+      },
+      makeContext({ sendToClient: () => {} }),
+    );
+    const body = parseResult<{
+      success: boolean;
+      replacements_made: number;
+      content_changed: boolean;
+    }>(result);
+    expect(body.success).toBe(true);
+    expect(body.replacements_made).toBe(2);
+    expect(body.content_changed).toBe(true);
+    expect(getDocumentById("doc-regex-limit")?.content).toBe("b/a d/c e@f");
+  });
+
+  test("no matches returns success with zero replacements", () => {
+    const result = executeDocumentReplaceText(
+      { surface_id: "doc-replace", find: "nonexistent", replace: "x" },
+      makeContext({ sendToClient: () => {} }),
+    );
+    const body = parseResult<{
+      success: boolean;
+      replacements_made: number;
+      content_changed: boolean;
+    }>(result);
+    expect(body.success).toBe(true);
+    expect(body.replacements_made).toBe(0);
+    expect(body.content_changed).toBe(false);
+    expect(getDocumentById("doc-replace")?.content).toBe("foo bar foo baz foo");
+  });
+
+  test("word_count is recalculated after replacement", () => {
+    const before = getDocumentById("doc-replace");
+    expect(before?.wordCount).toBe(5);
+
+    executeDocumentReplaceText(
+      { surface_id: "doc-replace", find: "foo", replace: "one two" },
+      makeContext({ sendToClient: () => {} }),
+    );
+    const after = getDocumentById("doc-replace");
+    expect(after?.wordCount).toBe(8);
+  });
+
+  test("access control blocks non-guardian from other conversations", () => {
+    const remoteContext = makeContext({
+      trustClass: "trusted_contact",
+      executionChannel: "slack",
+      sendToClient: () => {},
+    });
+    const result = executeDocumentReplaceText(
+      { surface_id: "doc-other", find: "other", replace: "x" },
+      remoteContext,
+    );
+    expect(result.isError).toBe(true);
+    const body = parseResult<{ error: string }>(result);
+    expect(body.error).toBe("Document not found");
+    expect(getDocumentById("doc-other")?.content).toBe("other content");
+  });
+
+  test("client is notified via sendToClient with updated content", () => {
+    const messages: unknown[] = [];
+    const sendToClient = (msg: unknown) => {
+      messages.push(msg);
+    };
+    executeDocumentReplaceText(
+      { surface_id: "doc-replace", find: "foo", replace: "qux" },
+      makeContext({ sendToClient }),
+    );
+    expect(messages).toHaveLength(1);
+    const msg = messages[0] as {
+      type: string;
+      surfaceId: string;
+      markdown: string;
+      mode: string;
+    };
+    expect(msg.type).toBe("document_editor_update");
+    expect(msg.surfaceId).toBe("doc-replace");
+    expect(msg.mode).toBe("replace");
+    expect(msg.markdown).toBe("qux bar qux baz qux");
+  });
+});

package/src/__tests__/dynamic-page-surface.test.ts

@@ -41,7 +41,7 @@ describe("DynamicPageSurfaceData shape", () => {
 
 describe("Tool definition includes dynamic_page", () => {
   test("input_schema surface_type enum includes dynamic_page", () => {
-    const definition = uiShowTool.getDefinition();
+    const definition = uiShowTool;
     const surfaceTypeEnum = (
       definition.input_schema as {
         properties: { surface_type: { enum: string[] } };
@@ -52,7 +52,7 @@ describe("Tool definition includes dynamic_page", () => {
   });
 
   test("description mentions dynamic_page", () => {
-    const definition = uiShowTool.getDefinition();
+    const definition = uiShowTool;
     expect(definition.description).toContain("dynamic_page");
   });
 });

package/src/__tests__/email-html-renderer.test.ts

@@ -49,6 +49,18 @@ describe("markdownToEmailHtml", () => {
     expect(result).toBe("");
   });
 
+  test("converts literal backslash-n after normalization", () => {
+    // LLMs often produce literal "\n" instead of real newlines.
+    // handleEmailSend normalizes them before calling markdownToEmailHtml.
+    const raw = "Hi Noa,\\n\\nTesting line breaks!\\n\\nThanks!";
+    const normalized = raw.replace(/\\n/g, "\n");
+    const result = markdownToEmailHtml(normalized);
+    expect(result).toContain("<p>Hi Noa,</p>");
+    expect(result).toContain("<p>Testing line breaks!</p>");
+    expect(result).toContain("<p>Thanks!</p>");
+    expect(result).not.toContain("\\n");
+  });
+
   test("handles multiline markdown email", () => {
     const md = `Hi there,
 

package/src/__tests__/first-greeting.test.ts

@@ -4,8 +4,12 @@ import { describe, expect, it } from "bun:test";
 
 const tempDir = process.env.VELLUM_WORKSPACE_DIR!;
 
-const { isWakeUpGreeting, getCannedFirstGreeting, CANNED_FIRST_GREETING } =
-  await import("../daemon/first-greeting.js");
+const {
+  isWakeUpGreeting,
+  getCannedFirstGreeting,
+  buildScanFirstMessage,
+  CANNED_FIRST_GREETING,
+} = await import("../daemon/first-greeting.js");
 import type { OnboardingGreetingContext } from "../daemon/first-greeting.js";
 
 describe("first-greeting", () => {
@@ -270,6 +274,23 @@ describe("first-greeting", () => {
     });
   });
 
+  describe("buildScanFirstMessage", () => {
+    it("website variant includes 'my website' and the URL", () => {
+      const msg = buildScanFirstMessage("https://acme.com", "website");
+      expect(msg).toContain("my website");
+      expect(msg).toContain("https://acme.com");
+    });
+
+    it("content-source variant includes 'content' and the URL", () => {
+      const msg = buildScanFirstMessage(
+        "https://blog.acme.com/post",
+        "content-source",
+      );
+      expect(msg).toContain("content");
+      expect(msg).toContain("https://blog.acme.com/post");
+    });
+  });
+
   describe("tasks and tools fields are ignored", () => {
     it("tasks do not appear in output", () => {
       const greeting = getCannedFirstGreeting({