@vellumai/assistant 0.4.49 → 0.4.51

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

@@ -1,269 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  isConflictKindEligible,
-  isConflictKindPairEligible,
-  isConflictUserEvidenced,
-  isDurableInstructionStatement,
-  isStatementConflictEligible,
-  isTransientTrackingStatement,
-  isUserEvidencedVerificationState,
-} from "../memory/conflict-policy.js";
-
-describe("conflict-policy", () => {
-  const config = { conflictableKinds: ["preference", "profile", "constraint"] };
-
-  describe("isConflictKindEligible", () => {
-    test("returns true for eligible kind", () => {
-      expect(isConflictKindEligible("preference", config)).toBe(true);
-      expect(isConflictKindEligible("profile", config)).toBe(true);
-      expect(isConflictKindEligible("constraint", config)).toBe(true);
-    });
-
-    test("returns false for ineligible kind", () => {
-      expect(isConflictKindEligible("project", config)).toBe(false);
-      expect(isConflictKindEligible("todo", config)).toBe(false);
-      expect(isConflictKindEligible("fact", config)).toBe(false);
-    });
-  });
-
-  describe("isConflictKindPairEligible", () => {
-    test("returns true when both kinds are eligible", () => {
-      expect(isConflictKindPairEligible("preference", "profile", config)).toBe(
-        true,
-      );
-    });
-
-    test("returns false when existing kind is ineligible", () => {
-      expect(isConflictKindPairEligible("project", "preference", config)).toBe(
-        false,
-      );
-    });
-
-    test("returns false when candidate kind is ineligible", () => {
-      expect(isConflictKindPairEligible("preference", "todo", config)).toBe(
-        false,
-      );
-    });
-
-    test("returns false when both kinds are ineligible", () => {
-      expect(isConflictKindPairEligible("project", "todo", config)).toBe(false);
-    });
-  });
-
-  describe("isTransientTrackingStatement", () => {
-    test("detects PR URLs", () => {
-      expect(
-        isTransientTrackingStatement(
-          "Track https://github.com/org/repo/pull/5526",
-        ),
-      ).toBe(true);
-    });
-
-    test("detects issue/ticket references", () => {
-      expect(isTransientTrackingStatement("Track PR #5526 and #5525")).toBe(
-        true,
-      );
-      expect(isTransientTrackingStatement("See issue #42 for details")).toBe(
-        true,
-      );
-      expect(isTransientTrackingStatement("Filed ticket 1234")).toBe(true);
-    });
-
-    test("detects tracking language", () => {
-      expect(isTransientTrackingStatement("While we wait for CI to pass")).toBe(
-        true,
-      );
-      expect(isTransientTrackingStatement("This PR needs review")).toBe(true);
-    });
-
-    test("does not flag generic time words as transient", () => {
-      expect(isTransientTrackingStatement("The deadline is today")).toBe(false);
-      expect(isTransientTrackingStatement("I need this right now")).toBe(false);
-    });
-
-    test("does not flag durable statements", () => {
-      expect(
-        isTransientTrackingStatement(
-          "Always answer with concise bullet points",
-        ),
-      ).toBe(false);
-      expect(isTransientTrackingStatement("User prefers dark mode")).toBe(
-        false,
-      );
-    });
-
-    test("does not false-positive on non-PR URLs", () => {
-      expect(
-        isTransientTrackingStatement("Visit https://example.com for docs"),
-      ).toBe(false);
-    });
-  });
-
-  describe("isDurableInstructionStatement", () => {
-    test("detects durable instruction cues", () => {
-      expect(
-        isDurableInstructionStatement(
-          "Always answer with concise bullet points",
-        ),
-      ).toBe(true);
-      expect(
-        isDurableInstructionStatement("Never use semicolons in JavaScript"),
-      ).toBe(true);
-      expect(
-        isDurableInstructionStatement("Use concise format for status updates"),
-      ).toBe(true);
-      expect(
-        isDurableInstructionStatement("The default database is Postgres"),
-      ).toBe(true);
-    });
-
-    test("rejects statements without durable cues", () => {
-      expect(isDurableInstructionStatement("Check the build output")).toBe(
-        false,
-      );
-      expect(isDurableInstructionStatement("Run the migration script")).toBe(
-        false,
-      );
-    });
-  });
-
-  describe("isStatementConflictEligible", () => {
-    test("rejects transient statements for any kind", () => {
-      expect(isStatementConflictEligible("preference", "Track PR #5526")).toBe(
-        false,
-      );
-      expect(
-        isStatementConflictEligible("instruction", "This PR needs review"),
-      ).toBe(false);
-    });
-
-    test("accepts durable instruction statements", () => {
-      expect(
-        isStatementConflictEligible(
-          "instruction",
-          "Always use TypeScript strict mode",
-        ),
-      ).toBe(true);
-      expect(
-        isStatementConflictEligible("style", "Default to concise format"),
-      ).toBe(true);
-    });
-
-    test("rejects non-durable instruction statements", () => {
-      expect(
-        isStatementConflictEligible("instruction", "Run the build first"),
-      ).toBe(false);
-      expect(isStatementConflictEligible("style", "Check the output")).toBe(
-        false,
-      );
-    });
-
-    test("accepts non-transient statements for non-instruction kinds", () => {
-      expect(
-        isStatementConflictEligible("preference", "User prefers dark mode"),
-      ).toBe(true);
-      expect(
-        isStatementConflictEligible("fact", "User works at Acme Corp"),
-      ).toBe(true);
-    });
-
-    test("rejects kinds not in conflictableKinds when config is provided", () => {
-      const policyConfig = { conflictableKinds: ["preference", "profile"] };
-      expect(
-        isStatementConflictEligible(
-          "fact",
-          "User works at Acme Corp",
-          policyConfig,
-        ),
-      ).toBe(false);
-      expect(
-        isStatementConflictEligible(
-          "preference",
-          "User prefers dark mode",
-          policyConfig,
-        ),
-      ).toBe(true);
-    });
-
-    test("skips kind check when config is omitted", () => {
-      expect(
-        isStatementConflictEligible("fact", "User works at Acme Corp"),
-      ).toBe(true);
-    });
-  });
-
-  describe("isUserEvidencedVerificationState", () => {
-    test("accepts user_reported", () => {
-      expect(isUserEvidencedVerificationState("user_reported")).toBe(true);
-    });
-
-    test("accepts user_confirmed", () => {
-      expect(isUserEvidencedVerificationState("user_confirmed")).toBe(true);
-    });
-
-    test("accepts legacy_import", () => {
-      expect(isUserEvidencedVerificationState("legacy_import")).toBe(true);
-    });
-
-    test("rejects assistant_inferred", () => {
-      expect(isUserEvidencedVerificationState("assistant_inferred")).toBe(
-        false,
-      );
-    });
-
-    test("rejects unknown states", () => {
-      expect(isUserEvidencedVerificationState("")).toBe(false);
-      expect(isUserEvidencedVerificationState("auto_detected")).toBe(false);
-      expect(isUserEvidencedVerificationState("pending")).toBe(false);
-    });
-  });
-
-  describe("isConflictUserEvidenced", () => {
-    test("returns true when existing side is user-evidenced", () => {
-      expect(
-        isConflictUserEvidenced("user_reported", "assistant_inferred"),
-      ).toBe(true);
-      expect(
-        isConflictUserEvidenced("user_confirmed", "assistant_inferred"),
-      ).toBe(true);
-      expect(
-        isConflictUserEvidenced("legacy_import", "assistant_inferred"),
-      ).toBe(true);
-    });
-
-    test("returns true when candidate side is user-evidenced", () => {
-      expect(
-        isConflictUserEvidenced("assistant_inferred", "user_reported"),
-      ).toBe(true);
-      expect(
-        isConflictUserEvidenced("assistant_inferred", "user_confirmed"),
-      ).toBe(true);
-      expect(
-        isConflictUserEvidenced("assistant_inferred", "legacy_import"),
-      ).toBe(true);
-    });
-
-    test("returns true when both sides are user-evidenced", () => {
-      expect(isConflictUserEvidenced("user_reported", "user_confirmed")).toBe(
-        true,
-      );
-      expect(isConflictUserEvidenced("legacy_import", "user_reported")).toBe(
-        true,
-      );
-    });
-
-    test("returns false when neither side is user-evidenced", () => {
-      expect(
-        isConflictUserEvidenced("assistant_inferred", "assistant_inferred"),
-      ).toBe(false);
-    });
-
-    test("returns false for unknown states on both sides", () => {
-      expect(isConflictUserEvidenced("auto_detected", "pending")).toBe(false);
-      expect(
-        isConflictUserEvidenced("assistant_inferred", "auto_detected"),
-      ).toBe(false);
-    });
-  });
-});

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

@@ -1,372 +0,0 @@
-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 { eq } from "drizzle-orm";
-
-const testDir = mkdtempSync(join(tmpdir(), "conflict-store-test-"));
-
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  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: () => () => {},
-    }),
-}));
-
-import {
-  applyConflictResolution,
-  createOrUpdatePendingConflict,
-  getConflictById,
-  getPendingConflictByPair,
-  listPendingConflictDetails,
-  listPendingConflicts,
-  resolveConflict,
-} 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 */
-  }
-});
-
-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");
-}
-
-function insertItemPair(
-  suffix: string,
-  scopeId = "default",
-  opts?: {
-    existingVerificationState?: string;
-    candidateVerificationState?: string;
-  },
-): { 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:
-          opts?.existingVerificationState ?? "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:
-          opts?.candidateVerificationState ?? "assistant_inferred",
-        scopeId,
-        firstSeenAt: now,
-        lastSeenAt: now,
-      },
-    ])
-    .run();
-
-  return { existingItemId, candidateItemId };
-}
-
-describe("conflict-store", () => {
-  beforeEach(() => {
-    resetTables();
-  });
-
-  test("creates and fetches a pending conflict", () => {
-    const pair = insertItemPair("create");
-    const conflict = createOrUpdatePendingConflict({
-      scopeId: "default",
-      existingItemId: pair.existingItemId,
-      candidateItemId: pair.candidateItemId,
-      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(byPair?.id).toBe(conflict.id);
-  });
-
-  test("deduplicates unresolved pair and updates fields in place", () => {
-    const pair = insertItemPair("dedupe");
-    const first = createOrUpdatePendingConflict({
-      scopeId: "default",
-      existingItemId: pair.existingItemId,
-      candidateItemId: pair.candidateItemId,
-      relationship: "contradiction",
-      clarificationQuestion: "First question",
-    });
-
-    const second = createOrUpdatePendingConflict({
-      scopeId: "default",
-      existingItemId: pair.existingItemId,
-      candidateItemId: pair.candidateItemId,
-      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);
-  });
-
-  test("allows a new pending row for the same pair after resolution", () => {
-    const pair = insertItemPair("reopen");
-    const first = createOrUpdatePendingConflict({
-      scopeId: "default",
-      existingItemId: pair.existingItemId,
-      candidateItemId: pair.candidateItemId,
-      relationship: "ambiguous_contradiction",
-    });
-
-    const resolved = resolveConflict(first.id, {
-      status: "resolved_keep_existing",
-      resolutionNote: "User confirmed existing statement is correct.",
-    });
-    expect(resolved?.status).toBe("resolved_keep_existing");
-    expect(typeof resolved?.resolvedAt).toBe("number");
-
-    const reopened = createOrUpdatePendingConflict({
-      scopeId: "default",
-      existingItemId: pair.existingItemId,
-      candidateItemId: pair.candidateItemId,
-      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);
-  });
-
-  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",
-      existingItemId: defaultA.existingItemId,
-      candidateItemId: defaultA.candidateItemId,
-      relationship: "ambiguous_contradiction",
-    });
-    const conflictB = createOrUpdatePendingConflict({
-      scopeId: "default",
-      existingItemId: defaultB.existingItemId,
-      candidateItemId: defaultB.candidateItemId,
-      relationship: "ambiguous_contradiction",
-    });
-    createOrUpdatePendingConflict({
-      scopeId: "workspace-b",
-      existingItemId: otherScope.existingItemId,
-      candidateItemId: otherScope.candidateItemId,
-      relationship: "ambiguous_contradiction",
-    });
-
-    resolveConflict(conflictB.id, {
-      status: "dismissed",
-      resolutionNote: "Irrelevant to active context",
-    });
-
-    const pendingDefault = listPendingConflicts("default");
-    expect(pendingDefault).toHaveLength(1);
-    expect(pendingDefault[0].id).toBe(conflictA.id);
-    expect(pendingDefault[0].status).toBe("pending_clarification");
-  });
-
-  test("listPendingConflictDetails joins current statements and verification states", () => {
-    const pair = insertItemPair("details", "workspace-a", {
-      existingVerificationState: "user_confirmed",
-      candidateVerificationState: "assistant_inferred",
-    });
-    createOrUpdatePendingConflict({
-      scopeId: "workspace-a",
-      existingItemId: pair.existingItemId,
-      candidateItemId: pair.candidateItemId,
-      relationship: "ambiguous_contradiction",
-      clarificationQuestion: "Which framework should I keep?",
-    });
-
-    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].existingVerificationState).toBe("user_confirmed");
-    expect(details[0].candidateVerificationState).toBe("assistant_inferred");
-  });
-
-  test("applyConflictResolution keeps candidate and resolves conflict row", () => {
-    const pair = insertItemPair("apply-candidate");
-    const conflict = createOrUpdatePendingConflict({
-      scopeId: "default",
-      existingItemId: pair.existingItemId,
-      candidateItemId: pair.candidateItemId,
-      relationship: "ambiguous_contradiction",
-    });
-
-    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 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");
-  });
-
-  test("applyConflictResolution merge updates existing item statement", () => {
-    const pair = insertItemPair("apply-merge");
-    const conflict = createOrUpdatePendingConflict({
-      scopeId: "default",
-      existingItemId: pair.existingItemId,
-      candidateItemId: pair.candidateItemId,
-      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 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 updatedConflict = getConflictById(conflict.id);
-
-    expect(existing?.statement).toBe(merged);
-    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;
-    const now = Date.now();
-
-    raw.run(
-      `INSERT INTO memory_item_conflicts (
-        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-a', 'default', '${pair.existingItemId}', '${pair.candidateItemId}',
-        'ambiguous_contradiction', 'pending_clarification', NULL, NULL, NULL, NULL, ${now}, ${now}
-      )`,
-    );
-
-    expect(() => {
-      raw.run(
-        `INSERT INTO memory_item_conflicts (
-          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}
-        )`,
-      );
-    }).toThrow();
-
-    expect(() => {
-      raw.run(
-        `INSERT INTO memory_item_conflicts (
-          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}
-        )`,
-      );
-    }).not.toThrow();
-  });
-});