@vellumai/assistant 0.4.17 → 0.4.19

package/src/__tests__/conflict-store.test.ts

@@ -1,28 +1,29 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+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";
 
-import { afterAll, beforeEach, describe, expect, mock,test } from 'bun:test';
-import { eq } from 'drizzle-orm';
+import { eq } from "drizzle-orm";
 
-const testDir = mkdtempSync(join(tmpdir(), 'conflict-store-test-'));
+const testDir = mkdtempSync(join(tmpdir(), "conflict-store-test-"));
 
-mock.module('../util/platform.js', () => ({
+mock.module("../util/platform.js", () => ({
   getDataDir: () => testDir,
-  isMacOS: () => process.platform === 'darwin',
-  isLinux: () => process.platform === 'linux',
-  isWindows: () => process.platform === 'win32',
-  getSocketPath: () => join(testDir, 'test.sock'),
-  getPidPath: () => join(testDir, 'test.pid'),
-  getDbPath: () => join(testDir, 'test.db'),
-  getLogPath: () => join(testDir, 'test.log'),
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getSocketPath: () => join(testDir, "test.sock"),
+  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: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
 }));
 
 import {
@@ -34,183 +35,196 @@ import {
   listPendingConflicts,
   markConflictAsked,
   resolveConflict,
-} from '../memory/conflict-store.js';
-import { getDb, initializeDb, resetDb } from '../memory/db.js';
-import { memoryItems } from '../memory/schema.js';
+} from "../memory/conflict-store.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { memoryItems } from "../memory/schema.js";
 
 initializeDb();
 
 afterAll(() => {
   resetDb();
-  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
 });
 
 function resetTables() {
   const db = getDb();
-  db.run('DELETE FROM memory_item_conflicts');
-  db.run('DELETE FROM memory_item_sources');
-  db.run('DELETE FROM memory_items');
+  db.run("DELETE FROM memory_item_conflicts");
+  db.run("DELETE FROM memory_item_sources");
+  db.run("DELETE FROM memory_items");
 }
 
-function insertItemPair(suffix: string, scopeId = 'default'): { existingItemId: string; candidateItemId: string } {
+function insertItemPair(
+  suffix: string,
+  scopeId = "default",
+): { existingItemId: string; candidateItemId: string } {
   const db = getDb();
   const now = Date.now();
   const existingItemId = `existing-${suffix}`;
   const candidateItemId = `candidate-${suffix}`;
-  db.insert(memoryItems).values([
-    {
-      id: existingItemId,
-      kind: 'fact',
-      subject: 'framework preference',
-      statement: `Existing statement ${suffix}`,
-      status: 'active',
-      confidence: 0.8,
-      importance: 0.5,
-      fingerprint: `fp-existing-${suffix}`,
-      verificationState: 'assistant_inferred',
-      scopeId,
-      firstSeenAt: now,
-      lastSeenAt: now,
-    },
-    {
-      id: candidateItemId,
-      kind: 'fact',
-      subject: 'framework preference',
-      statement: `Candidate statement ${suffix}`,
-      status: 'pending_clarification',
-      confidence: 0.8,
-      importance: 0.5,
-      fingerprint: `fp-candidate-${suffix}`,
-      verificationState: 'assistant_inferred',
-      scopeId,
-      firstSeenAt: now,
-      lastSeenAt: now,
-    },
-  ]).run();
+  db.insert(memoryItems)
+    .values([
+      {
+        id: existingItemId,
+        kind: "fact",
+        subject: "framework preference",
+        statement: `Existing statement ${suffix}`,
+        status: "active",
+        confidence: 0.8,
+        importance: 0.5,
+        fingerprint: `fp-existing-${suffix}`,
+        verificationState: "assistant_inferred",
+        scopeId,
+        firstSeenAt: now,
+        lastSeenAt: now,
+      },
+      {
+        id: candidateItemId,
+        kind: "fact",
+        subject: "framework preference",
+        statement: `Candidate statement ${suffix}`,
+        status: "pending_clarification",
+        confidence: 0.8,
+        importance: 0.5,
+        fingerprint: `fp-candidate-${suffix}`,
+        verificationState: "assistant_inferred",
+        scopeId,
+        firstSeenAt: now,
+        lastSeenAt: now,
+      },
+    ])
+    .run();
 
   return { existingItemId, candidateItemId };
 }
 
-describe('conflict-store', () => {
+describe("conflict-store", () => {
   beforeEach(() => {
     resetTables();
   });
 
-  test('creates and fetches a pending conflict', () => {
-    const pair = insertItemPair('create');
+  test("creates and fetches a pending conflict", () => {
+    const pair = insertItemPair("create");
     const conflict = createOrUpdatePendingConflict({
-      scopeId: 'default',
+      scopeId: "default",
       existingItemId: pair.existingItemId,
       candidateItemId: pair.candidateItemId,
-      relationship: 'ambiguous_contradiction',
-      clarificationQuestion: 'Do you prefer React or Vue?',
+      relationship: "ambiguous_contradiction",
+      clarificationQuestion: "Do you prefer React or Vue?",
     });
 
     expect(conflict.id).toBeDefined();
-    expect(conflict.status).toBe('pending_clarification');
-    expect(conflict.scopeId).toBe('default');
-    expect(conflict.relationship).toBe('ambiguous_contradiction');
-    expect(conflict.clarificationQuestion).toBe('Do you prefer React or Vue?');
-
-    const byPair = getPendingConflictByPair('default', pair.existingItemId, pair.candidateItemId);
+    expect(conflict.status).toBe("pending_clarification");
+    expect(conflict.scopeId).toBe("default");
+    expect(conflict.relationship).toBe("ambiguous_contradiction");
+    expect(conflict.clarificationQuestion).toBe("Do you prefer React or Vue?");
+
+    const byPair = getPendingConflictByPair(
+      "default",
+      pair.existingItemId,
+      pair.candidateItemId,
+    );
     expect(byPair?.id).toBe(conflict.id);
   });
 
-  test('deduplicates unresolved pair and updates fields in place', () => {
-    const pair = insertItemPair('dedupe');
+  test("deduplicates unresolved pair and updates fields in place", () => {
+    const pair = insertItemPair("dedupe");
     const first = createOrUpdatePendingConflict({
-      scopeId: 'default',
+      scopeId: "default",
       existingItemId: pair.existingItemId,
       candidateItemId: pair.candidateItemId,
-      relationship: 'contradiction',
-      clarificationQuestion: 'First question',
+      relationship: "contradiction",
+      clarificationQuestion: "First question",
     });
 
     const second = createOrUpdatePendingConflict({
-      scopeId: 'default',
+      scopeId: "default",
       existingItemId: pair.existingItemId,
       candidateItemId: pair.candidateItemId,
-      relationship: 'ambiguous_contradiction',
-      clarificationQuestion: 'Second question',
+      relationship: "ambiguous_contradiction",
+      clarificationQuestion: "Second question",
     });
 
     expect(second.id).toBe(first.id);
-    expect(second.relationship).toBe('ambiguous_contradiction');
-    expect(second.clarificationQuestion).toBe('Second question');
-    expect(listPendingConflicts('default')).toHaveLength(1);
+    expect(second.relationship).toBe("ambiguous_contradiction");
+    expect(second.clarificationQuestion).toBe("Second question");
+    expect(listPendingConflicts("default")).toHaveLength(1);
   });
 
-  test('allows a new pending row for the same pair after resolution', () => {
-    const pair = insertItemPair('reopen');
+  test("allows a new pending row for the same pair after resolution", () => {
+    const pair = insertItemPair("reopen");
     const first = createOrUpdatePendingConflict({
-      scopeId: 'default',
+      scopeId: "default",
       existingItemId: pair.existingItemId,
       candidateItemId: pair.candidateItemId,
-      relationship: 'ambiguous_contradiction',
+      relationship: "ambiguous_contradiction",
     });
 
     const resolved = resolveConflict(first.id, {
-      status: 'resolved_keep_existing',
-      resolutionNote: 'User confirmed existing statement is correct.',
+      status: "resolved_keep_existing",
+      resolutionNote: "User confirmed existing statement is correct.",
     });
-    expect(resolved?.status).toBe('resolved_keep_existing');
-    expect(typeof resolved?.resolvedAt).toBe('number');
+    expect(resolved?.status).toBe("resolved_keep_existing");
+    expect(typeof resolved?.resolvedAt).toBe("number");
 
     const reopened = createOrUpdatePendingConflict({
-      scopeId: 'default',
+      scopeId: "default",
       existingItemId: pair.existingItemId,
       candidateItemId: pair.candidateItemId,
-      relationship: 'ambiguous_contradiction',
-      clarificationQuestion: 'Please confirm again',
+      relationship: "ambiguous_contradiction",
+      clarificationQuestion: "Please confirm again",
     });
 
     expect(reopened.id).not.toBe(first.id);
-    expect(getConflictById(first.id)?.status).toBe('resolved_keep_existing');
-    expect(listPendingConflicts('default')).toHaveLength(1);
+    expect(getConflictById(first.id)?.status).toBe("resolved_keep_existing");
+    expect(listPendingConflicts("default")).toHaveLength(1);
   });
 
-  test('lists only pending conflicts for a scope', () => {
-    const defaultA = insertItemPair('scope-a');
-    const defaultB = insertItemPair('scope-b');
-    const otherScope = insertItemPair('scope-other', 'workspace-b');
+  test("lists only pending conflicts for a scope", () => {
+    const defaultA = insertItemPair("scope-a");
+    const defaultB = insertItemPair("scope-b");
+    const otherScope = insertItemPair("scope-other", "workspace-b");
 
     const conflictA = createOrUpdatePendingConflict({
-      scopeId: 'default',
+      scopeId: "default",
       existingItemId: defaultA.existingItemId,
       candidateItemId: defaultA.candidateItemId,
-      relationship: 'ambiguous_contradiction',
+      relationship: "ambiguous_contradiction",
     });
     const conflictB = createOrUpdatePendingConflict({
-      scopeId: 'default',
+      scopeId: "default",
       existingItemId: defaultB.existingItemId,
       candidateItemId: defaultB.candidateItemId,
-      relationship: 'ambiguous_contradiction',
+      relationship: "ambiguous_contradiction",
     });
     createOrUpdatePendingConflict({
-      scopeId: 'workspace-b',
+      scopeId: "workspace-b",
       existingItemId: otherScope.existingItemId,
       candidateItemId: otherScope.candidateItemId,
-      relationship: 'ambiguous_contradiction',
+      relationship: "ambiguous_contradiction",
     });
 
     resolveConflict(conflictB.id, {
-      status: 'dismissed',
-      resolutionNote: 'Irrelevant to active context',
+      status: "dismissed",
+      resolutionNote: "Irrelevant to active context",
     });
 
-    const pendingDefault = listPendingConflicts('default');
+    const pendingDefault = listPendingConflicts("default");
     expect(pendingDefault).toHaveLength(1);
     expect(pendingDefault[0].id).toBe(conflictA.id);
-    expect(pendingDefault[0].status).toBe('pending_clarification');
+    expect(pendingDefault[0].status).toBe("pending_clarification");
   });
 
-  test('markConflictAsked updates lastAskedAt', () => {
-    const pair = insertItemPair('asked');
+  test("markConflictAsked updates lastAskedAt", () => {
+    const pair = insertItemPair("asked");
     const conflict = createOrUpdatePendingConflict({
-      scopeId: 'default',
+      scopeId: "default",
       existingItemId: pair.existingItemId,
       candidateItemId: pair.candidateItemId,
-      relationship: 'ambiguous_contradiction',
+      relationship: "ambiguous_contradiction",
     });
 
     const askedAt = 1_734_000_000_000;
@@ -220,80 +234,104 @@ describe('conflict-store', () => {
     expect(updated?.updatedAt).toBe(askedAt);
   });
 
-  test('listPendingConflictDetails joins current statements', () => {
-    const pair = insertItemPair('details', 'workspace-a');
+  test("listPendingConflictDetails joins current statements", () => {
+    const pair = insertItemPair("details", "workspace-a");
     createOrUpdatePendingConflict({
-      scopeId: 'workspace-a',
+      scopeId: "workspace-a",
       existingItemId: pair.existingItemId,
       candidateItemId: pair.candidateItemId,
-      relationship: 'ambiguous_contradiction',
-      clarificationQuestion: 'Which framework should I keep?',
+      relationship: "ambiguous_contradiction",
+      clarificationQuestion: "Which framework should I keep?",
     });
 
-    const details = listPendingConflictDetails('workspace-a');
+    const details = listPendingConflictDetails("workspace-a");
     expect(details).toHaveLength(1);
-    expect(details[0].existingStatement).toBe('Existing statement details');
-    expect(details[0].candidateStatement).toBe('Candidate statement details');
-    expect(details[0].existingKind).toBe('fact');
-    expect(details[0].candidateKind).toBe('fact');
+    expect(details[0].existingStatement).toBe("Existing statement details");
+    expect(details[0].candidateStatement).toBe("Candidate statement details");
+    expect(details[0].existingKind).toBe("fact");
+    expect(details[0].candidateKind).toBe("fact");
   });
 
-  test('applyConflictResolution keeps candidate and resolves conflict row', () => {
-    const pair = insertItemPair('apply-candidate');
+  test("applyConflictResolution keeps candidate and resolves conflict row", () => {
+    const pair = insertItemPair("apply-candidate");
     const conflict = createOrUpdatePendingConflict({
-      scopeId: 'default',
+      scopeId: "default",
       existingItemId: pair.existingItemId,
       candidateItemId: pair.candidateItemId,
-      relationship: 'ambiguous_contradiction',
+      relationship: "ambiguous_contradiction",
     });
 
-    expect(applyConflictResolution({
-      conflictId: conflict.id,
-      resolution: 'keep_candidate',
-      resolutionNote: 'User confirmed candidate statement.',
-    })).toBe(true);
+    expect(
+      applyConflictResolution({
+        conflictId: conflict.id,
+        resolution: "keep_candidate",
+        resolutionNote: "User confirmed candidate statement.",
+      }),
+    ).toBe(true);
 
     const db = getDb();
-    const existing = db.select().from(memoryItems).where(eq(memoryItems.id, pair.existingItemId)).get();
-    const candidate = db.select().from(memoryItems).where(eq(memoryItems.id, pair.candidateItemId)).get();
+    const existing = db
+      .select()
+      .from(memoryItems)
+      .where(eq(memoryItems.id, pair.existingItemId))
+      .get();
+    const candidate = db
+      .select()
+      .from(memoryItems)
+      .where(eq(memoryItems.id, pair.candidateItemId))
+      .get();
     const updatedConflict = getConflictById(conflict.id);
 
-    expect(typeof existing?.invalidAt).toBe('number');
-    expect(existing?.status).toBe('superseded');
-    expect(candidate?.status).toBe('active');
-    expect(updatedConflict?.status).toBe('resolved_keep_candidate');
+    expect(typeof existing?.invalidAt).toBe("number");
+    expect(existing?.status).toBe("superseded");
+    expect(candidate?.status).toBe("active");
+    expect(updatedConflict?.status).toBe("resolved_keep_candidate");
   });
 
-  test('applyConflictResolution merge updates existing item statement', () => {
-    const pair = insertItemPair('apply-merge');
+  test("applyConflictResolution merge updates existing item statement", () => {
+    const pair = insertItemPair("apply-merge");
     const conflict = createOrUpdatePendingConflict({
-      scopeId: 'default',
+      scopeId: "default",
       existingItemId: pair.existingItemId,
       candidateItemId: pair.candidateItemId,
-      relationship: 'ambiguous_contradiction',
+      relationship: "ambiguous_contradiction",
     });
 
-    const merged = 'Use React for dashboard pages and Vue for marketing pages.';
-    expect(applyConflictResolution({
-      conflictId: conflict.id,
-      resolution: 'merge',
-      mergedStatement: merged,
-      resolutionNote: 'User clarified both apply in different contexts.',
-    })).toBe(true);
+    const merged = "Use React for dashboard pages and Vue for marketing pages.";
+    expect(
+      applyConflictResolution({
+        conflictId: conflict.id,
+        resolution: "merge",
+        mergedStatement: merged,
+        resolutionNote: "User clarified both apply in different contexts.",
+      }),
+    ).toBe(true);
 
     const db = getDb();
-    const existing = db.select().from(memoryItems).where(eq(memoryItems.id, pair.existingItemId)).get();
-    const candidate = db.select().from(memoryItems).where(eq(memoryItems.id, pair.candidateItemId)).get();
+    const existing = db
+      .select()
+      .from(memoryItems)
+      .where(eq(memoryItems.id, pair.existingItemId))
+      .get();
+    const candidate = db
+      .select()
+      .from(memoryItems)
+      .where(eq(memoryItems.id, pair.candidateItemId))
+      .get();
     const updatedConflict = getConflictById(conflict.id);
 
     expect(existing?.statement).toBe(merged);
-    expect(candidate?.status).toBe('superseded');
-    expect(updatedConflict?.status).toBe('resolved_merge');
+    expect(candidate?.status).toBe("superseded");
+    expect(updatedConflict?.status).toBe("resolved_merge");
   });
 
-  test('enforces pending-pair uniqueness with a partial index', () => {
-    const pair = insertItemPair('index');
-    const raw = (getDb() as unknown as { $client: import('bun:sqlite').Database }).$client;
+  test("enforces pending-pair uniqueness with a partial index", () => {
+    const pair = insertItemPair("index");
+    const raw = (
+      getDb() as unknown as {
+        $client: import("bun:sqlite").Database;
+      }
+    ).$client;
     const now = Date.now();
 
     raw.run(
@@ -312,8 +350,12 @@ describe('conflict-store', () => {
           id, scope_id, existing_item_id, candidate_item_id, relationship, status,
           clarification_question, resolution_note, last_asked_at, resolved_at, created_at, updated_at
         ) VALUES (
-          'conflict-index-b', 'default', '${pair.existingItemId}', '${pair.candidateItemId}',
-          'ambiguous_contradiction', 'pending_clarification', NULL, NULL, NULL, NULL, ${now + 1}, ${now + 1}
+          'conflict-index-b', 'default', '${pair.existingItemId}', '${
+            pair.candidateItemId
+          }',
+          'ambiguous_contradiction', 'pending_clarification', NULL, NULL, NULL, NULL, ${
+            now + 1
+          }, ${now + 1}
         )`,
       );
     }).toThrow();
@@ -324,8 +366,12 @@ describe('conflict-store', () => {
           id, scope_id, existing_item_id, candidate_item_id, relationship, status,
           clarification_question, resolution_note, last_asked_at, resolved_at, created_at, updated_at
         ) VALUES (
-          'conflict-index-c', 'default', '${pair.existingItemId}', '${pair.candidateItemId}',
-          'ambiguous_contradiction', 'resolved_keep_candidate', NULL, NULL, NULL, ${now + 2}, ${now + 2}, ${now + 2}
+          'conflict-index-c', 'default', '${pair.existingItemId}', '${
+            pair.candidateItemId
+          }',
+          'ambiguous_contradiction', 'resolved_keep_candidate', NULL, NULL, NULL, ${
+            now + 2
+          }, ${now + 2}, ${now + 2}
         )`,
       );
     }).not.toThrow();