@vellumai/assistant 0.8.2 → 0.8.4

package/src/__tests__/dm-backfill.test.ts

@@ -40,6 +40,20 @@ mock.module("../runtime/gateway-client.js", () => ({
   deliverChannelReply: async () => {},
 }));
 
+mock.module("../messaging/providers/slack/adapter.js", () => ({
+  withSlackBotToken: async (
+    _account: string | undefined,
+    fn: (token: string) => Promise<unknown>,
+  ) => fn("test-slack-token"),
+  resolveSlackBotUserId: async (
+    _account: string | undefined,
+    botId: string,
+  ) => {
+    if (botId === "B_ASSISTANT") return "U_BOT";
+    return null;
+  },
+}));
+
 import type { Message } from "../messaging/provider-types.js";
 
 // `backfillDm` is the only piece of the slack provider surface this test
@@ -59,6 +73,11 @@ mock.module("../messaging/providers/slack/backfill.js", () => ({
   backfillThread: () => backfillThreadMock(),
 }));
 
+import {
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../config/loader.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
@@ -88,6 +107,13 @@ function resetState(): void {
   db.run("DELETE FROM contact_channels");
   db.run("DELETE FROM contacts");
   db.run("DELETE FROM external_conversation_bindings");
+  setConfiguredSlackBotUserId("U_BOT");
+}
+
+function setConfiguredSlackBotUserId(botUserId: string): void {
+  const raw = loadRawConfig();
+  setNestedValue(raw, "slack.botUserId", botUserId);
+  saveRawConfig(raw);
 }
 
 function seedActiveMember(): void {
@@ -494,6 +520,44 @@ describe("PR 23 — Slack DM cold-start backfill", () => {
     expect(botRow?.provenanceRequesterIdentifier).toBe("B_BOT");
   });
 
+  test("skips Slack assistant new-thread placeholder during DM backfill", async () => {
+    backfillDmMock.mockImplementation(async () => [
+      makeBackfilledMessage({
+        id: "1700000000.000001",
+        text: "New Assistant Thread",
+        sender: { id: "B_ASSISTANT", name: "Ada" },
+        metadata: { isBot: true, slackBotId: "B_ASSISTANT" },
+      }),
+      makeBackfilledMessage({
+        id: "1700000000.000002",
+        text: "real bot context",
+        sender: { id: "B_ASSISTANT", name: "Ada" },
+        metadata: { isBot: true, slackBotId: "B_ASSISTANT" },
+      }),
+      makeBackfilledMessage({
+        id: "1700000000.000003",
+        text: "New Assistant Thread",
+        sender: { id: "B_OTHER", name: "Build Bot" },
+        metadata: { isBot: true, slackBotId: "B_OTHER" },
+      }),
+    ]);
+
+    await handleChannelInbound(
+      buildDmRequest("live new DM"),
+      noopProcessMessage,
+      TEST_BEARER_TOKEN,
+    );
+
+    const rows = readPersistedSlackRows();
+    expect(rows.map((row) => row.rawContent).sort()).toEqual([
+      "New Assistant Thread",
+      "real bot context",
+    ]);
+    expect(
+      rows.some((row) => row.slackMeta?.actorExternalUserId === "B_OTHER"),
+    ).toBe(true);
+  });
+
   test("backfill skips channelTs values already stored", async () => {
     // First DM: backfill returns three rows.
     backfillDmMock.mockImplementation(async () => [

package/src/__tests__/dm-persistence.test.ts

@@ -179,6 +179,39 @@ describe("PR 16 — Slack DM persistence parity", () => {
     expect(slackMeta!.displayName).toBeUndefined();
   });
 
+  test("DM inbound persists Slack actor timezone metadata", async () => {
+    const ctx = createSlackTurnContext();
+    await persistQueuedMessageBody(
+      ctx,
+      "hello across timezones",
+      [],
+      "req-dm-timezone",
+      {
+        slackInbound: {
+          channelId: "D0123DM",
+          channelTs: "1700000000.777777",
+          displayName: "Alice",
+          actorTimezone: "America/New_York",
+          actorTimezoneLabel: "ET",
+          actorTimezoneOffsetSeconds: -18000,
+          timestampTimezone: "America/New_York",
+          timestampTimezoneLabel: "ET",
+          speakerTimezoneLabel: "ET",
+        },
+      },
+      undefined,
+    );
+
+    const slackMeta = lastPersistedSlackMeta();
+    expect(slackMeta).not.toBeNull();
+    expect(slackMeta!.actorTimezone).toBe("America/New_York");
+    expect(slackMeta!.actorTimezoneLabel).toBe("ET");
+    expect(slackMeta!.actorTimezoneOffsetSeconds).toBe(-18000);
+    expect(slackMeta!.timestampTimezone).toBe("America/New_York");
+    expect(slackMeta!.timestampTimezoneLabel).toBe("ET");
+    expect(slackMeta!.speakerTimezoneLabel).toBe("ET");
+  });
+
   test("DM and channel-message envelopes differ only by threadTs", async () => {
     // Capture the channel-thread case first.
     const ctx = createSlackTurnContext();

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");
+  });
+});