@vellumai/assistant 0.8.3 → 0.8.4

package/src/__tests__/injector-document-comments.test.ts

@@ -0,0 +1,378 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { CommentRecord } from "../documents/document-comments-store.js";
+
+let listCommentsMock = mock((..._args: unknown[]) => [] as CommentRecord[]);
+
+mock.module("../documents/document-comments-store.js", () => ({
+  listComments: (...args: unknown[]) => listCommentsMock(...args),
+}));
+
+const { DEFAULT_INJECTOR_ORDER, defaultInjectorsPlugin } =
+  await import("../plugins/defaults/injectors.js");
+import type { Injector, TurnContext } from "../plugins/types.js";
+
+function findInjector(name: string): Injector {
+  const injector = defaultInjectorsPlugin.injectors?.find(
+    (candidate) => candidate.name === name,
+  );
+  if (!injector) {
+    throw new Error(`injector '${name}' not registered`);
+  }
+  return injector;
+}
+
+function makeContext(overrides: Partial<TurnContext> = {}): TurnContext {
+  return {
+    requestId: "req-test",
+    conversationId: "conv-test",
+    turnIndex: 0,
+    trust: { sourceChannel: "vellum", trustClass: "guardian" },
+    ...overrides,
+  };
+}
+
+function makeComment(overrides: Partial<CommentRecord> = {}): CommentRecord {
+  return {
+    id: "comment-abc",
+    surfaceId: "doc-1",
+    conversationId: "conv-test",
+    author: "user",
+    content: "Fix this paragraph",
+    anchorStart: null,
+    anchorEnd: null,
+    anchorText: null,
+    parentCommentId: null,
+    status: "open",
+    resolvedBy: null,
+    resolvedAt: null,
+    createdAt: 1000,
+    updatedAt: 1000,
+    ...overrides,
+  };
+}
+
+const injector = findInjector("document-comments");
+
+describe("document-comments injector", () => {
+  beforeEach(() => {
+    listCommentsMock = mock(() => [] as CommentRecord[]);
+  });
+
+  test("returns null when no active documents exist", async () => {
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: { mode: "full", activeDocuments: [] },
+      }),
+    );
+    expect(block).toBeNull();
+  });
+
+  test("returns null when activeDocuments is undefined", async () => {
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: { mode: "full" },
+      }),
+    );
+    expect(block).toBeNull();
+  });
+
+  test("returns null when mode is minimal", async () => {
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "minimal",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "My Doc",
+              wordCount: 100,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+    expect(block).toBeNull();
+  });
+
+  test("returns null when no documents have open comments", async () => {
+    listCommentsMock = mock(() => []);
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "My Doc",
+              wordCount: 100,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+    expect(block).toBeNull();
+  });
+
+  test("formats doc-level comments correctly", async () => {
+    listCommentsMock = mock(() => [
+      makeComment({
+        id: "comment-id1",
+        content: "This introduction needs more context",
+        anchorText: null,
+      }),
+    ]);
+
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "My Doc",
+              wordCount: 100,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    expect(block!.id).toBe("document-comments");
+    expect(block!.placement).toBe("prepend-user-tail");
+    expect(block!.text).toContain("(doc-level)");
+    expect(block!.text).toContain("Comment #comment-id1");
+    expect(block!.text).toContain('"This introduction needs more context"');
+  });
+
+  test("formats inline comments with anchor text", async () => {
+    listCommentsMock = mock(() => [
+      makeComment({
+        id: "comment-id2",
+        content: "Cite the research paper",
+        anchorText: "the quick brown fox",
+        anchorStart: 10,
+        anchorEnd: 29,
+      }),
+    ]);
+
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "My Doc",
+              wordCount: 100,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    expect(block!.text).toContain('inline, anchored to "the quick brown fox"');
+    expect(block!.text).toContain("Comment #comment-id2");
+    expect(block!.text).toContain('"Cite the research paper"');
+  });
+
+  test("mixes doc-level and inline comments for the same document", async () => {
+    listCommentsMock = mock(() => [
+      makeComment({
+        id: "comment-id1",
+        content: "This introduction needs more context",
+        anchorText: null,
+      }),
+      makeComment({
+        id: "comment-id2",
+        content: "Cite the research paper",
+        anchorText: "the quick brown fox",
+        anchorStart: 10,
+        anchorEnd: 29,
+      }),
+    ]);
+
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-xxx",
+              title: "Title",
+              wordCount: 200,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    expect(block!.text).toContain('Document: "Title" (surface_id: "doc-xxx")');
+    expect(block!.text).toContain(
+      '- Comment #comment-id1 (doc-level): "This introduction needs more context"',
+    );
+    expect(block!.text).toContain(
+      '- Comment #comment-id2 (inline, anchored to "the quick brown fox"): "Cite the research paper"',
+    );
+  });
+
+  test("respects the 10-comment cap per document", async () => {
+    const comments = Array.from({ length: 15 }, (_, i) =>
+      makeComment({
+        id: `comment-${i}`,
+        content: `Comment number ${i}`,
+        createdAt: 1000 + i,
+      }),
+    );
+    listCommentsMock = mock(() => comments);
+
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "Big Doc",
+              wordCount: 500,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    // The store returns ASC order; .slice(-10) takes the 10 most recent
+    for (let i = 5; i < 15; i++) {
+      expect(block!.text).toContain(`Comment #comment-${i}`);
+    }
+    // Earlier comments should be excluded (use exact line match to avoid
+    // substring collisions like "comment-1" matching "comment-10")
+    for (let i = 0; i < 5; i++) {
+      expect(block!.text).not.toContain(`Comment #comment-${i} (`);
+    }
+  });
+
+  test("handles multiple documents with comments", async () => {
+    let callCount = 0;
+    listCommentsMock = mock(() => {
+      callCount++;
+      if (callCount === 1) {
+        return [makeComment({ id: "c1", content: "Fix typo" })];
+      }
+      return [
+        makeComment({
+          id: "c2",
+          content: "Add citation",
+          anchorText: "some text",
+          anchorStart: 0,
+          anchorEnd: 9,
+        }),
+      ];
+    });
+
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "Doc A",
+              wordCount: 100,
+              updatedAt: 1000,
+            },
+            {
+              surfaceId: "doc-2",
+              title: "Doc B",
+              wordCount: 200,
+              updatedAt: 2000,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    expect(block!.text).toContain('Document: "Doc A" (surface_id: "doc-1")');
+    expect(block!.text).toContain('Document: "Doc B" (surface_id: "doc-2")');
+    expect(block!.text).toContain("Comment #c1");
+    expect(block!.text).toContain("Comment #c2");
+  });
+
+  test("skips documents with zero open comments", async () => {
+    let callCount = 0;
+    listCommentsMock = mock(() => {
+      callCount++;
+      if (callCount === 1) return [];
+      return [makeComment({ id: "c1", content: "Needs work" })];
+    });
+
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "Empty Doc",
+              wordCount: 100,
+              updatedAt: 1000,
+            },
+            {
+              surfaceId: "doc-2",
+              title: "Commented Doc",
+              wordCount: 200,
+              updatedAt: 2000,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    expect(block!.text).not.toContain("Empty Doc");
+    expect(block!.text).toContain("Commented Doc");
+  });
+
+  test("has the correct order value", () => {
+    expect(injector.order).toBe(DEFAULT_INJECTOR_ORDER.documentComments);
+    expect(injector.order).toBe(46);
+  });
+
+  test("wraps output in <document_comments> tags with instructions", async () => {
+    listCommentsMock = mock(() => [
+      makeComment({ id: "c1", content: "Fix this" }),
+    ]);
+
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "My Doc",
+              wordCount: 100,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    expect(block!.text).toMatch(/^<document_comments>/);
+    expect(block!.text).toMatch(/<\/document_comments>$/);
+    expect(block!.text).toContain("comment_resolve");
+  });
+});

package/src/__tests__/injector-pkb-v2-silenced.test.ts

@@ -3,8 +3,8 @@
  *
  * When `getConfig().memory.v2.enabled` is true:
  *   - `pkb-context` silences itself (concept pages own retrieval).
- *   - `pkb-reminder` still fires (its body is generic recall/remember
- *     guidance) but skips the PKB-search hints — those name PKB paths.
+ *   - `pkb-reminder` silences itself (the v2 static `<memory>` block
+ *     supplants the generic recall/remember nudge).
  *   - `now-md` fires unchanged (workspace state, independent of PKB).
  *
  * Mocks `getConfig` at the module level so each test can flip the effective
@@ -85,7 +85,7 @@ describe("PKB injector v2 cutover behavior", () => {
     expect(texts.some((t) => t.includes("<NOW.md"))).toBe(true);
   });
 
-  test("v2 active → pkb-context silenced; pkb-reminder + now-md still fire", async () => {
+  test("v2 active → pkb-context and pkb-reminder silenced; now-md still fires", async () => {
     v2Active = true;
     const result = await applyRuntimeInjections(RUN_MESSAGES, {
       turnContext: makeTurnContext(),
@@ -99,29 +99,8 @@ describe("PKB injector v2 cutover behavior", () => {
 
     const texts = tailTexts(result.messages);
     expect(texts.some((t) => t.includes("<knowledge_base>"))).toBe(false);
-    expect(texts.some((t) => t.includes("<system_reminder>"))).toBe(true);
+    expect(texts.some((t) => t.includes("<system_reminder>"))).toBe(false);
     expect(texts.some((t) => t.includes("<NOW.md"))).toBe(true);
     expect(texts).toContain("What next?");
   });
-
-  test("v2 active → pkb-reminder body fires without the hybrid-search hints", async () => {
-    v2Active = true;
-    const result = await applyRuntimeInjections(RUN_MESSAGES, {
-      turnContext: makeTurnContext(),
-      pkbActive: true,
-      pkbScopeId: "scope-default",
-      pkbRoot: "/tmp/pkb",
-      pkbConversation: { messages: [] },
-      // Provide a query vector so the v1 path WOULD have called searchPkbFiles
-      // and rendered hints. Under v2, the call is skipped and the reminder
-      // is rendered with empty hints — i.e. no "files look especially
-      // relevant" line.
-      pkbQueryVector: [0.1, 0.2, 0.3],
-    });
-
-    const texts = tailTexts(result.messages);
-    const reminder = texts.find((t) => t.includes("<system_reminder>"));
-    expect(reminder).toBeDefined();
-    expect(reminder).not.toContain("files look especially relevant");
-  });
 });

package/src/__tests__/list-messages-attachments.test.ts

@@ -78,7 +78,7 @@ describe("handleListMessages attachments", () => {
     const stored = uploadAttachment("photo.png", "image/png", IMAGE_BASE64);
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     expect(body.messages).toHaveLength(1);
@@ -103,7 +103,7 @@ describe("handleListMessages attachments", () => {
     );
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     expect(body.messages).toHaveLength(1);
@@ -125,7 +125,7 @@ describe("handleListMessages attachments", () => {
     const stored = uploadAttachment("result.png", "image/png", IMAGE_BASE64);
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     expect(body.messages).toHaveLength(1);
@@ -153,7 +153,7 @@ describe("handleListMessages attachments", () => {
     linkAttachmentToMessage(msg.id, imgStored.id, 0);
     linkAttachmentToMessage(msg.id, docStored.id, 1);
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     const attachments = body.messages[0].attachments!;
@@ -177,7 +177,7 @@ describe("handleListMessages no_response filtering", () => {
       JSON.stringify([{ type: "text", text: "<no_response/>" }]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
       messages: { content: string; textSegments: string[] }[];
     };
@@ -199,7 +199,7 @@ describe("handleListMessages no_response filtering", () => {
       ]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
       messages: { content: string; textSegments: string[] }[];
     };
@@ -228,7 +228,7 @@ describe("handleListMessages no_response filtering", () => {
       ]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
       messages: {
         content: string;
@@ -252,7 +252,7 @@ describe("handleListMessages no_response filtering", () => {
       JSON.stringify([{ type: "text", text: "What does <no_response/> do?" }]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
       messages: { content: string }[];
     };
@@ -308,7 +308,7 @@ describe("handleListMessages pagination", () => {
     const conv = createConversation();
     await insertMessages(conv.id, 5);
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as unknown as PaginatedResponse;
 
     expect(body.messages).toHaveLength(5);
@@ -322,7 +322,7 @@ describe("handleListMessages pagination", () => {
     await insertMessages(conv.id, 5);
 
     const args = createPaginatedArgs(conv.id, { limit: "3" });
-    const response = handleListMessages(args, null);
+    const response = handleListMessages(args);
     const body = response as unknown as PaginatedResponse;
 
     // Option A: without beforeTimestamp, all messages are returned regardless of limit
@@ -339,7 +339,7 @@ describe("handleListMessages pagination", () => {
       beforeTimestamp: String(msgs[7].createdAt),
       limit: "3",
     });
-    const response = handleListMessages(args, null);
+    const response = handleListMessages(args);
     const body = response as unknown as PaginatedResponse;
 
     expect(body.messages).toHaveLength(3);
@@ -360,7 +360,7 @@ describe("handleListMessages pagination", () => {
       beforeTimestamp: String(msgs[1].createdAt),
       limit: "10",
     });
-    const response = handleListMessages(args, null);
+    const response = handleListMessages(args);
     const body = response as unknown as PaginatedResponse;
 
     const ids = body.messages.map((m) => m.id);
@@ -378,7 +378,7 @@ describe("handleListMessages pagination", () => {
       beforeTimestamp: String(msgs[4].createdAt + 1),
       limit: "10",
     });
-    const response = handleListMessages(args, null);
+    const response = handleListMessages(args);
     const body = response as unknown as PaginatedResponse;
 
     expect(body.messages).toHaveLength(5);
@@ -394,7 +394,7 @@ describe("handleListMessages pagination", () => {
       beforeTimestamp: String(msgs[4].createdAt + 1),
       limit: "3",
     });
-    const response = handleListMessages(args, null);
+    const response = handleListMessages(args);
     const body = response as unknown as PaginatedResponse;
 
     expect(body.messages).toHaveLength(3);
@@ -405,7 +405,7 @@ describe("handleListMessages pagination", () => {
 
   test("empty / nonexistent conversation → empty messages, no pagination metadata", async () => {
     const args = createPaginatedArgs("nonexistent-conv-id");
-    const response = handleListMessages(args, null);
+    const response = handleListMessages(args);
     const body = response as unknown as PaginatedResponse;
 
     expect(body.messages).toEqual([]);
@@ -418,13 +418,17 @@ describe("handleListMessages pagination", () => {
     const conv = createConversation();
     const args = createPaginatedArgs(conv.id, { limit: "abc" });
 
-    expect(() => handleListMessages(args, null)).toThrow("limit must be a valid number");
+    expect(() => handleListMessages(args)).toThrow(
+      "limit must be a valid number",
+    );
   });
 
   test("invalid beforeTimestamp (NaN) → 400", async () => {
     const conv = createConversation();
     const args = createPaginatedArgs(conv.id, { beforeTimestamp: "abc" });
 
-    expect(() => handleListMessages(args, null)).toThrow("beforeTimestamp must be a valid number");
+    expect(() => handleListMessages(args)).toThrow(
+      "beforeTimestamp must be a valid number",
+    );
   });
 });