@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/conflict-intent-tokenization.test.ts

@@ -1,23 +1,28 @@
-import { describe, expect, test } from 'bun:test';
-
-import { areStatementsCoherent, computeConflictRelevance, overlapRatio as _overlapRatio,tokenizeForConflictRelevance as _tokenizeForConflictRelevance } from '../memory/conflict-intent.js';
-
-describe('tokenizeForConflictRelevance hardening', () => {
-  test('excludes numeric-only tokens from relevance', () => {
-    const relevance = computeConflictRelevance(
-      'Check PR 5526',
-      { existingStatement: 'Track PR 5525 for review.', candidateStatement: 'Track PR 5526 for review.' },
-    );
+import { describe, expect, test } from "bun:test";
+
+import {
+  areStatementsCoherent,
+  computeConflictRelevance,
+  overlapRatio as _overlapRatio,
+  tokenizeForConflictRelevance as _tokenizeForConflictRelevance,
+} from "../memory/conflict-intent.js";
+
+describe("tokenizeForConflictRelevance hardening", () => {
+  test("excludes numeric-only tokens from relevance", () => {
+    const relevance = computeConflictRelevance("Check PR 5526", {
+      existingStatement: "Track PR 5525 for review.",
+      candidateStatement: "Track PR 5526 for review.",
+    });
     // Numeric tokens "5526" and "5525" should be excluded, so overlap is minimal
     expect(relevance).toBeLessThan(0.5);
   });
 
-  test('excludes URL boilerplate tokens from relevance', () => {
+  test("excludes URL boilerplate tokens from relevance", () => {
     const relevance = computeConflictRelevance(
-      'Check https://github.com/org/repo/pull/123',
+      "Check https://github.com/org/repo/pull/123",
       {
-        existingStatement: 'Review https://github.com/org/repo/pull/456',
-        candidateStatement: 'Review https://github.com/org/repo/pull/789',
+        existingStatement: "Review https://github.com/org/repo/pull/456",
+        candidateStatement: "Review https://github.com/org/repo/pull/789",
       },
     );
     // URL tokens like "https", "github", "pull" should be excluded;
@@ -25,34 +30,34 @@ describe('tokenizeForConflictRelevance hardening', () => {
     expect(relevance).toBeLessThanOrEqual(0.5);
   });
 
-  test('URL-embedded tracking tokens are stripped, standalone usage preserved', () => {
+  test("URL-embedded tracking tokens are stripped, standalone usage preserved", () => {
     // URLs containing "issue", "pull", etc. are stripped entirely before tokenizing
     const urlRelevance = computeConflictRelevance(
-      'Check https://github.com/org/repo/issues/42',
+      "Check https://github.com/org/repo/issues/42",
       {
-        existingStatement: 'Review https://github.com/org/repo/issues/10',
-        candidateStatement: 'Review https://github.com/org/repo/issues/11',
+        existingStatement: "Review https://github.com/org/repo/issues/10",
+        candidateStatement: "Review https://github.com/org/repo/issues/11",
       },
     );
     expect(urlRelevance).toBeLessThanOrEqual(0.5);
 
     // Standalone "issue" is preserved as a meaningful token
     const standaloneRelevance = computeConflictRelevance(
-      'should I file an issue?',
+      "should I file an issue?",
       {
-        existingStatement: 'File an issue when bugs are found.',
-        candidateStatement: 'Skip filing an issue for minor bugs.',
+        existingStatement: "File an issue when bugs are found.",
+        candidateStatement: "Skip filing an issue for minor bugs.",
       },
     );
     expect(standaloneRelevance).toBeGreaterThan(0);
   });
 
-  test('strips scheme-less bare domain URLs from relevance', () => {
+  test("strips scheme-less bare domain URLs from relevance", () => {
     const relevance = computeConflictRelevance(
-      'Check github.com/org/repo/pull/123',
+      "Check github.com/org/repo/pull/123",
       {
-        existingStatement: 'Review gitlab.com/org/repo/issues/456',
-        candidateStatement: 'Review github.com/org/repo/pull/789',
+        existingStatement: "Review gitlab.com/org/repo/issues/456",
+        candidateStatement: "Review github.com/org/repo/pull/789",
       },
     );
     // Bare URLs should be stripped entirely; tokens like "pull", "issues"
@@ -60,24 +65,21 @@ describe('tokenizeForConflictRelevance hardening', () => {
     expect(relevance).toBeLessThanOrEqual(0.5);
   });
 
-  test('preserves dotted identifiers that look like file paths', () => {
-    const relevance = computeConflictRelevance(
-      'Use index.ts/runtime parser',
-      {
-        existingStatement: 'Keep index.ts/runtime approach.',
-        candidateStatement: 'Switch to config.ts/runtime approach.',
-      },
-    );
+  test("preserves dotted identifiers that look like file paths", () => {
+    const relevance = computeConflictRelevance("Use index.ts/runtime parser", {
+      existingStatement: "Keep index.ts/runtime approach.",
+      candidateStatement: "Switch to config.ts/runtime approach.",
+    });
     // File-like identifiers should NOT be stripped as URLs
     expect(relevance).toBeGreaterThan(0);
   });
 
-  test('still computes meaningful relevance for real content tokens', () => {
+  test("still computes meaningful relevance for real content tokens", () => {
     const relevance = computeConflictRelevance(
-      'Should I use React for frontend?',
+      "Should I use React for frontend?",
       {
-        existingStatement: 'Use React for frontend work.',
-        candidateStatement: 'Use Vue for frontend work.',
+        existingStatement: "Use React for frontend work.",
+        candidateStatement: "Use Vue for frontend work.",
       },
     );
     // Real content tokens like "react", "frontend" should still match
@@ -85,58 +87,74 @@ describe('tokenizeForConflictRelevance hardening', () => {
   });
 });
 
-describe('statement coherence (areStatementsCoherent)', () => {
-  test('unrelated statements are incoherent', () => {
-    expect(areStatementsCoherent(
-      'The default model for the summarize CLI is google/gemini-3-flash-preview.',
-      "User's favorite color is blue.",
-    )).toBe(false);
+describe("statement coherence (areStatementsCoherent)", () => {
+  test("unrelated statements are incoherent", () => {
+    expect(
+      areStatementsCoherent(
+        "The default model for the summarize CLI is google/gemini-3-flash-preview.",
+        "User's favorite color is blue.",
+      ),
+    ).toBe(false);
   });
 
-  test('related statements are coherent', () => {
-    expect(areStatementsCoherent(
-      "User's favorite color is blue.",
-      "User's favorite color is green.",
-    )).toBe(true);
+  test("related statements are coherent", () => {
+    expect(
+      areStatementsCoherent(
+        "User's favorite color is blue.",
+        "User's favorite color is green.",
+      ),
+    ).toBe(true);
   });
 
-  test('topically similar preferences are coherent', () => {
-    expect(areStatementsCoherent(
-      'Use React for frontend work.',
-      'Use Vue for frontend work.',
-    )).toBe(true);
+  test("topically similar preferences are coherent", () => {
+    expect(
+      areStatementsCoherent(
+        "Use React for frontend work.",
+        "Use Vue for frontend work.",
+      ),
+    ).toBe(true);
   });
 
-  test('completely disjoint technical topics are incoherent', () => {
-    expect(areStatementsCoherent(
-      'Always use PostgreSQL for database storage.',
-      'The preferred terminal font is JetBrains Mono.',
-    )).toBe(false);
+  test("completely disjoint technical topics are incoherent", () => {
+    expect(
+      areStatementsCoherent(
+        "Always use PostgreSQL for database storage.",
+        "The preferred terminal font is JetBrains Mono.",
+      ),
+    ).toBe(false);
   });
 
-  test('short technical terms (3 chars) are preserved for coherence', () => {
+  test("short technical terms (3 chars) are preserved for coherence", () => {
     // "vim" and "css" are 3 chars — should not be filtered
-    expect(areStatementsCoherent(
-      'Use Vim for editing.',
-      'Use Emacs instead of Vim.',
-    )).toBe(true);
-
-    expect(areStatementsCoherent(
-      'Use CSS grid for layouts.',
-      'Use CSS flexbox for layouts.',
-    )).toBe(true);
-
-    expect(areStatementsCoherent(
-      'Use npm for installs.',
-      'Use npm with --legacy-peer-deps.',
-    )).toBe(true);
+    expect(
+      areStatementsCoherent(
+        "Use Vim for editing.",
+        "Use Emacs instead of Vim.",
+      ),
+    ).toBe(true);
+
+    expect(
+      areStatementsCoherent(
+        "Use CSS grid for layouts.",
+        "Use CSS flexbox for layouts.",
+      ),
+    ).toBe(true);
+
+    expect(
+      areStatementsCoherent(
+        "Use npm for installs.",
+        "Use npm with --legacy-peer-deps.",
+      ),
+    ).toBe(true);
   });
 
-  test('short terms with no shared context are still incoherent', () => {
+  test("short terms with no shared context are still incoherent", () => {
     // No shared tokens at all — completely different topics
-    expect(areStatementsCoherent(
-      'Vim is the preferred editor.',
-      'CSS grid handles page layouts.',
-    )).toBe(false);
+    expect(
+      areStatementsCoherent(
+        "Vim is the preferred editor.",
+        "CSS grid handles page layouts.",
+      ),
+    ).toBe(false);
   });
 });

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

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
 import {
   isConflictKindEligible,
@@ -6,117 +6,188 @@ import {
   isDurableInstructionStatement,
   isStatementConflictEligible,
   isTransientTrackingStatement,
-} from '../memory/conflict-policy.js';
+} from "../memory/conflict-policy.js";
 
-describe('conflict-policy', () => {
-  const config = { conflictableKinds: ['preference', 'profile', 'constraint'] };
+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);
+  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);
+    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);
+  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 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 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);
+    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);
+  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 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("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 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 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);
+    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("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("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);
     });
   });
 });