@vellumai/assistant 0.4.49 → 0.4.50

package/src/__tests__/clarification-resolver.test.ts

@@ -1,193 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-let llmCallCount = 0;
-let llmDelayMs = 0;
-let llmResolution:
-  | "keep_existing"
-  | "keep_candidate"
-  | "merge"
-  | "still_unclear" = "still_unclear";
-let llmResolvedStatement = "";
-let llmExplanation = "Unclear response from user.";
-
-mock.module("../providers/provider-send-message.js", () => ({
-  getConfiguredProvider: () => ({
-    sendMessage: async (
-      _messages: unknown,
-      _tools: unknown,
-      _system: unknown,
-      opts?: { signal?: AbortSignal },
-    ) => {
-      llmCallCount += 1;
-      if (llmDelayMs > 0) {
-        await new Promise((resolve, reject) => {
-          const timer = setTimeout(resolve, llmDelayMs);
-          opts?.signal?.addEventListener("abort", () => {
-            clearTimeout(timer);
-            reject(new Error("Request was aborted."));
-          });
-        });
-      }
-      return {
-        content: [
-          {
-            type: "tool_use" as const,
-            id: "test-tool-use-id",
-            name: "resolve_conflict",
-            input: {
-              resolution: llmResolution,
-              resolved_statement: llmResolvedStatement,
-              explanation: llmExplanation,
-            },
-          },
-        ],
-        model: "claude-haiku-4-5-20251001",
-        stopReason: "tool_use",
-        usage: { inputTokens: 0, outputTokens: 0 },
-      };
-    },
-  }),
-  createTimeout: (ms: number) => {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), ms);
-    return {
-      signal: controller.signal,
-      cleanup: () => clearTimeout(timer),
-    };
-  },
-  extractToolUse: (response: { content: Array<{ type: string }> }) => {
-    return response.content.find(
-      (b: { type: string }) => b.type === "tool_use",
-    );
-  },
-  userMessage: (text: string) => ({
-    role: "user",
-    content: [{ type: "text", text }],
-  }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    apiKeys: {
-      anthropic: "test-key",
-    },
-  }),
-}));
-
-import { resolveConflictClarification } from "../memory/clarification-resolver.js";
-
-beforeEach(() => {
-  llmCallCount = 0;
-  llmDelayMs = 0;
-  llmResolution = "still_unclear";
-  llmResolvedStatement = "";
-  llmExplanation = "Unclear response from user.";
-});
-
-describe("resolveConflictClarification", () => {
-  test("returns keep_existing from deterministic heuristic", async () => {
-    const result = await resolveConflictClarification({
-      existingStatement: "Use React for frontend work.",
-      candidateStatement: "Use Vue for frontend work.",
-      userMessage: "Keep the old React preference.",
-    });
-
-    expect(result.resolution).toBe("keep_existing");
-    expect(result.strategy).toBe("heuristic");
-    expect(llmCallCount).toBe(0);
-  });
-
-  test("returns keep_candidate from deterministic heuristic", async () => {
-    const result = await resolveConflictClarification({
-      existingStatement: "Use React for frontend work.",
-      candidateStatement: "Use Vue for frontend work.",
-      userMessage: "Use the new Vue note going forward.",
-    });
-
-    expect(result.resolution).toBe("keep_candidate");
-    expect(result.strategy).toBe("heuristic");
-    expect(llmCallCount).toBe(0);
-  });
-
-  test("returns merge from deterministic heuristic", async () => {
-    const result = await resolveConflictClarification({
-      existingStatement: "React is preferred for dashboards.",
-      candidateStatement: "Vue is preferred for marketing pages.",
-      userMessage:
-        "Both are true: React for dashboards and Vue for marketing pages.",
-    });
-
-    expect(result.resolution).toBe("merge");
-    expect(result.strategy).toBe("heuristic");
-    expect(result.resolvedStatement).toContain("Both are true");
-    expect(llmCallCount).toBe(0);
-  });
-
-  test("uses LLM fallback when heuristics are inconclusive", async () => {
-    llmResolution = "still_unclear";
-    llmExplanation = "The user message does not pick a side.";
-
-    const result = await resolveConflictClarification({
-      existingStatement: "Use React for frontend work.",
-      candidateStatement: "Use Vue for frontend work.",
-      userMessage: "Not sure yet.",
-    });
-
-    expect(result.resolution).toBe("still_unclear");
-    expect(result.strategy).toBe("llm");
-    expect(llmCallCount).toBe(1);
-  });
-
-  test("does not match cue substrings inside unrelated words", async () => {
-    llmResolution = "keep_candidate";
-    llmExplanation = "User wants Vue.";
-
-    // "told" contains "old" as a substring but not as a whole word
-    const result = await resolveConflictClarification({
-      existingStatement: "Use React for frontend work.",
-      candidateStatement: "Use Vue for frontend work.",
-      userMessage: "I told you, use Vue.",
-    });
-
-    expect(result.resolution).toBe("keep_candidate");
-    expect(result.strategy).toBe("llm");
-    expect(llmCallCount).toBe(1);
-  });
-
-  test("delegates to LLM when multiple cue categories match", async () => {
-    llmResolution = "keep_existing";
-    llmExplanation = "User wants the old one.";
-
-    // "either" is a merge cue, "old" is an existing cue — ambiguous
-    const result = await resolveConflictClarification({
-      existingStatement: "Use React for frontend work.",
-      candidateStatement: "Use Vue for frontend work.",
-      userMessage: "I don't want either, keep the old one.",
-    });
-
-    expect(result.resolution).toBe("keep_existing");
-    expect(result.strategy).toBe("llm");
-    expect(llmCallCount).toBe(1);
-  });
-
-  test("enforces timeout bound on LLM fallback", async () => {
-    llmResolution = "keep_candidate";
-    llmExplanation = "Prefer the newer statement.";
-    llmDelayMs = 50;
-
-    const result = await resolveConflictClarification(
-      {
-        existingStatement: "Use React for frontend work.",
-        candidateStatement: "Use Vue for frontend work.",
-        userMessage: "I cannot decide right now.",
-      },
-      { timeoutMs: 5 },
-    );
-
-    expect(result.resolution).toBe("still_unclear");
-    expect(result.strategy).toBe("llm_timeout");
-    expect(llmCallCount).toBe(1);
-  });
-});

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

@@ -1,160 +0,0 @@
-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", () => {
-    const relevance = computeConflictRelevance(
-      "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",
-      },
-    );
-    // URL tokens like "https", "github", "pull" should be excluded;
-    // only real content tokens like "repo" remain, keeping relevance low
-    expect(relevance).toBeLessThanOrEqual(0.5);
-  });
-
-  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",
-      {
-        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?",
-      {
-        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", () => {
-    const relevance = computeConflictRelevance(
-      "Check github.com/org/repo/pull/123",
-      {
-        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"
-    // embedded in paths must not contribute to overlap
-    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.",
-    });
-    // File-like identifiers should NOT be stripped as URLs
-    expect(relevance).toBeGreaterThan(0);
-  });
-
-  test("still computes meaningful relevance for real content tokens", () => {
-    const relevance = computeConflictRelevance(
-      "Should I use React for frontend?",
-      {
-        existingStatement: "Use React for frontend work.",
-        candidateStatement: "Use Vue for frontend work.",
-      },
-    );
-    // Real content tokens like "react", "frontend" should still match
-    expect(relevance).toBeGreaterThan(0);
-  });
-});
-
-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("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("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);
-  });
-
-  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);
-  });
-});

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